1 #include <stdio.h>
2
3 #define TESTINST1(RSval, RD) \
4 { \
5 unsigned int out = 0; \
6 __asm__ __volatile__( \
7 ".set noreorder" "\n\t" \
8 "move $"#RD", %1" "\n\t" \
9 "b end"#RSval "\n\t" \
10 "nop" "\n\t" \
11 "addiu $"#RD", $"#RD", 5" "\n\t" \
12 "end"#RSval":" "\n\t" \
13 "addiu $"#RD", $"#RD", 1" "\n\t" \
14 "move %0, $"#RD "\n\t" \
15 ".set reorder" "\n\t" \
16 : "=r" (out) \
17 : "r" (RSval) \
18 : #RD \
19 ); \
20 printf("B :: %d, RSval: %d\n", \
21 out, RSval); \
22 }
23
24 #define TESTINST2(RSval, RD) \
25 { \
26 unsigned int out = 0; \
27 __asm__ __volatile__( \
28 ".set noreorder" "\n\t" \
29 "move $"#RD", %1" "\n\t" \
30 "b end12"#RSval "\n\t" \
31 "addiu $"#RD", $"#RD", 3" "\n\t" \
32 "addiu $"#RD", $"#RD", 5" "\n\t" \
33 "end12"#RSval":" "\n\t" \
34 "addiu $"#RD", $"#RD", 3" "\n\t" \
35 "move %0, $"#RD "\n\t" \
36 ".set reorder" "\n\t" \
37 : "=r" (out) \
38 : "r" (RSval) \
39 : #RD \
40 ); \
41 printf("B :: %d, RSval: %d\n", \
42 out, RSval); \
43 }
44
45 #define TESTINST3(RSval, RD) \
46 { \
47 unsigned int out = 0; \
48 __asm__ __volatile__( \
49 ".set noreorder" "\n\t" \
50 "move $"#RD", %1" "\n\t" \
51 "bal end21"#RSval "\n\t" \
52 "nop" "\n\t" \
53 "addiu $"#RD", $"#RD", 5" "\n\t" \
54 "b r_end"#RSval "\n\t" \
55 "nop" "\n\t" \
56 "addiu $"#RD", $"#RD", 1" "\n\t" \
57 "end21"#RSval":" "\n\t" \
58 "addiu $"#RD", $"#RD", 1" "\n\t" \
59 "jr $ra" "\n\t" \
60 "nop" "\n\t" \
61 "r_end"#RSval":" "\n\t" \
62 "move %0, $"#RD "\n\t" \
63 ".set reorder" "\n\t" \
64 : "=r" (out) \
65 : "r" (RSval) \
66 : #RD, "ra" \
67 ); \
68 printf("B BAL JR :: %d, RSval: %d\n", \
69 out, RSval); \
70 }
71
72 #define TESTINST3j(RSval, RD) \
73 { \
74 unsigned int out = 0; \
75 __asm__ __volatile__( \
76 ".set noreorder" "\n\t" \
77 "move $"#RD", %1" "\n\t" \
78 "dla $t9, end31"#RSval "\n\t" \
79 "jal $t9" "\n\t" \
80 "nop" "\n\t" \
81 "addiu $"#RD", $"#RD", 5" "\n\t" \
82 "dla $t9, r_end11"#RSval "\n\t" \
83 "j $t9" "\n\t" \
84 "nop" "\n\t" \
85 "end31"#RSval":" "\n\t" \
86 "addiu $"#RD", $"#RD", 1" "\n\t" \
87 "jr $ra" "\n\t" \
88 "nop" "\n\t" \
89 "r_end11"#RSval":" "\n\t" \
90 "move %0, $"#RD "\n\t" \
91 ".set reorder" "\n\t" \
92 : "=r" (out) \
93 : "r" (RSval) \
94 : #RD, "t9" \
95 ); \
96 printf("J JAL JR :: %d, RSval: %d\n", \
97 out, RSval); \
98 }
99
100 #define TESTINST3ja(RSval, RD) \
101 { \
102 unsigned int out = 0; \
103 __asm__ __volatile__( \
104 ".set noreorder" "\n\t" \
105 "move $"#RD", %1" "\n\t" \
106 "dla $t9, end41"#RSval "\n\t" \
107 "jalr $t0, $t9" "\n\t" \
108 "nop" "\n\t" \
109 "addiu $"#RD", $"#RD", 5" "\n\t" \
110 "dla $t9, r_end21"#RSval "\n\t" \
111 "j $t9" "\n\t" \
112 "nop" "\n\t" \
113 "addiu $"#RD", $"#RD", 1" "\n\t" \
114 "end41"#RSval":" "\n\t" \
115 "addiu $"#RD", $"#RD", 1" "\n\t" \
116 "move $t9, $t0" "\n\t" \
117 "jr $t9" "\n\t" \
118 "nop" "\n\t" \
119 "r_end21"#RSval":" "\n\t" \
120 "move %0, $"#RD "\n\t" \
121 ".set reorder" "\n\t" \
122 : "=r" (out) \
123 : "r" (RSval) \
124 : #RD, "t0", "t9" \
125 ); \
126 printf("J JALR JR :: %d, RSval: %d\n", \
127 out, RSval); \
128 }
129
130 #define TESTINST4(instruction, RDval, RSval, RTval, RD, RS, RT) \
131 { \
132 unsigned int out = 0; \
133 __asm__ __volatile__( \
134 ".set noreorder" "\n\t" \
135 "move $"#RS", %1" "\n\t" \
136 "move $"#RT", %2" "\n\t" \
137 "move $"#RD", %3" "\n\t" \
138 instruction" $"#RS", $"#RT", end"instruction#RDval "\n\t" \
139 "nop" "\n\t" \
140 "addiu $"#RD", $"#RD", 5" "\n\t" \
141 "end"instruction#RDval":" "\n\t" \
142 "addiu $"#RD", $"#RD", 1" "\n\t" \
143 "move %0, $" #RD "\n\t" \
144 ".set reorder" "\n\t" \
145 : "=r" (out) \
146 : "r" (RSval), "r" (RTval), "r" (RDval) \
147 : #RD, #RS, #RT \
148 ); \
149 printf(instruction" :: out: %d, RDval: %d, RSval: %d, RTval: %d\n", \
150 out, RDval, RSval, RTval); \
151 }
152
153 #define TESTINST5(instruction, RDval, RSval, RD, RS) \
154 { \
155 unsigned int out = 0; \
156 __asm__ __volatile__( \
157 ".set noreorder" "\n\t" \
158 "move $"#RS", %1" "\n\t" \
159 "move $"#RD", %2" "\n\t" \
160 instruction" $"#RS", end"instruction#RDval "\n\t" \
161 "nop" "\n\t" \
162 "addiu $"#RD", $"#RD", 5" "\n\t" \
163 "end"instruction#RDval":" "\n\t" \
164 "addiu $"#RD", $"#RD", 1" "\n\t" \
165 "move %0, $"#RD "\n\t" \
166 ".set reorder" "\n\t" \
167 : "=r" (out) \
168 : "r" (RSval), "r" (RDval) \
169 : #RD, #RS \
170 ); \
171 printf(instruction" :: out: %d, RDval: %d, RSval: %d\n", \
172 out, RDval, RSval); \
173 }
174
175 #define TESTINST6(instruction, RDval, RSval, RD, RS) \
176 { \
177 unsigned int out = 0; \
178 __asm__ __volatile__( \
179 ".set noreorder" "\n\t" \
180 "move $"#RD", %2" "\n\t" \
181 "move $"#RS", %1" "\n\t" \
182 instruction" $"#RS", end21"instruction#RDval "\n\t" \
183 "nop" "\n\t" \
184 "addiu $"#RD", $"#RD", 5" "\n\t" \
185 "b r_end"instruction#RDval "\n\t" \
186 "nop" "\n\t" \
187 "end21"instruction#RDval":" "\n\t" \
188 "addiu $"#RD", $"#RD", 1" "\n\t" \
189 "jr $ra" "\n\t" \
190 "r_end"instruction#RDval":" "\n\t" \
191 "move %0, $"#RD "\n\t" \
192 ".set reorder" "\n\t" \
193 : "=r" (out) \
194 : "r" (RSval), "r" (RDval) \
195 : #RD, #RS, "ra" \
196 ); \
197 printf(instruction" :: out: %d, RDval: %d, RSval: %d\n", \
198 out, RDval, RSval); \
199 }
200
201 #define TESTINST4l(instruction, RDval, RSval, RTval, RD, RS, RT) \
202 { \
203 unsigned int out = 0; \
204 __asm__ __volatile__( \
205 ".set noreorder" "\n\t" \
206 "move $"#RS", %1" "\n\t" \
207 "move $"#RT", %2" "\n\t" \
208 "move $"#RD", %3" "\n\t" \
209 instruction" $"#RS", $"#RT", end"instruction#RDval "\n\t" \
210 "addiu $"#RD", $"#RD", 3" "\n\t" \
211 "addiu $"#RD", $"#RD", 5" "\n\t" \
212 "end"instruction#RDval":" "\n\t" \
213 "addiu $"#RD", $"#RD", 1" "\n\t" \
214 "move %0, $"#RD "\n\t" \
215 ".set reorder" "\n\t" \
216 : "=r" (out) \
217 : "r" (RSval), "r" (RTval), "r" (RDval) \
218 : #RD, #RS, #RT \
219 ); \
220 printf(instruction" :: out: %d, RDval: %d, RSval: %d, RTval: %d\n", \
221 out, RDval, RSval, RTval); \
222 }
223
224 #define TESTINST5l(instruction, RDval, RSval, RD, RS) \
225 { \
226 unsigned int out = 0; \
227 __asm__ __volatile__( \
228 ".set noreorder" "\n\t" \
229 "move $"#RS", %1" "\n\t" \
230 "move $"#RD", %2" "\n\t" \
231 instruction" $"#RS", end"instruction#RDval "\n\t" \
232 "addiu $"#RD", $"#RD", 3" "\n\t" \
233 "addiu $"#RD", $"#RD", 5" "\n\t" \
234 "end"instruction#RDval":" "\n\t" \
235 "addiu $"#RD", $"#RD", 1" "\n\t" \
236 "move %0, $"#RD "\n\t" \
237 ".set reorder" "\n\t" \
238 : "=r" (out) \
239 : "r" (RSval), "r" (RDval) \
240 : #RD, #RS \
241 ); \
242 printf(instruction" :: out: %d, RDval: %d, RSval: %d\n", \
243 out, RDval, RSval); \
244 }
245
246 #define TESTINST6l(instruction, RDval, RSval, RD, RS) \
247 { \
248 unsigned int out = 0; \
249 __asm__ __volatile__( \
250 ".set noreorder" "\n\t" \
251 "move $"#RD", %2" "\n\t" \
252 "move $"#RS", %1" "\n\t" \
253 instruction" $"#RS", end21"instruction#RDval "\n\t" \
254 "addiu $"#RD", $"#RD", 3" "\n\t" \
255 "addiu $"#RD", $"#RD", 5" "\n\t" \
256 "b r_end"instruction#RDval "\n\t" \
257 "nop" "\n\t" \
258 "end21"instruction#RDval":" "\n\t" \
259 "addiu $"#RD", $"#RD", 1" "\n\t" \
260 "jr $ra" "\n\t" \
261 "nop" "\n\t" \
262 "r_end"instruction#RDval":" "\n\t" \
263 "move %0, $"#RD "\n\t" \
264 ".set reorder" "\n\t" \
265 : "=r" (out) \
266 : "r" (RSval), "r" (RDval) \
267 : #RD, #RS, "ra" \
268 ); \
269 printf(instruction" :: out: %d, RDval: %d, RSval: %d\n", \
270 out, RDval, RSval); \
271 }
272
273
main()274 int main()
275 {
276
277 printf("b\n");
278 TESTINST1(0, 2);
279 TESTINST1(1, 3);
280 TESTINST1(2, 4);
281 TESTINST1(3, 5);
282 TESTINST1(4, 6);
283 TESTINST1(5, 7);
284 TESTINST1(6, 8);
285 TESTINST1(7, 9);
286 TESTINST1(8, 10);
287 TESTINST1(9, 11);
288 TESTINST1(10, 12);
289 TESTINST1(11, 13);
290 TESTINST1(12, 14);
291 TESTINST1(13, 15);
292 TESTINST1(14, 16);
293 TESTINST1(15, 17);
294 TESTINST1(16, 18);
295 TESTINST1(17, 19);
296 TESTINST1(18, 20);
297 TESTINST1(19, 21);
298 TESTINST1(20, 22);
299 TESTINST1(21, 23);
300 TESTINST1(22, 24);
301 TESTINST1(23, 25);
302
303 printf("b\n");
304 TESTINST2(0, 2);
305 TESTINST2(1, 3);
306 TESTINST2(2, 4);
307 TESTINST2(3, 5);
308 TESTINST2(4, 6);
309 TESTINST2(5, 7);
310 TESTINST2(6, 8);
311 TESTINST2(7, 9);
312 TESTINST2(8, 10);
313 TESTINST2(9, 11);
314 TESTINST2(10, 12);
315 TESTINST2(11, 13);
316 TESTINST2(12, 14);
317 TESTINST2(13, 15);
318 TESTINST2(14, 16);
319 TESTINST2(15, 17);
320 TESTINST2(16, 18);
321 TESTINST2(17, 19);
322 TESTINST2(18, 20);
323 TESTINST2(19, 21);
324 TESTINST2(20, 22);
325 TESTINST2(21, 23);
326 TESTINST2(22, 24);
327 TESTINST2(23, 25);
328
329 printf("b, bal, jr\n");
330 TESTINST3(0, 2);
331 TESTINST3(1, 3);
332 TESTINST3(2, 4);
333 TESTINST3(3, 5);
334 TESTINST3(4, 6);
335 TESTINST3(5, 7);
336 TESTINST3(6, 8);
337 TESTINST3(7, 9);
338 TESTINST3(8, 10);
339 TESTINST3(9, 11);
340 TESTINST3(10, 12);
341 TESTINST3(11, 13);
342 TESTINST3(12, 14);
343 TESTINST3(13, 15);
344 TESTINST3(14, 16);
345 TESTINST3(15, 17);
346 TESTINST3(16, 18);
347 TESTINST3(17, 19);
348 TESTINST3(18, 20);
349 TESTINST3(19, 21);
350 TESTINST3(20, 22);
351 TESTINST3(21, 23);
352 TESTINST3(22, 24);
353 TESTINST3(23, 25);
354
355 printf("--- BEQ --- if RSval == RTval then " \
356 "out = RDval + 1 else out = RDval + 6\n");
357 TESTINST4("beq", 0, 0, 1, 2, 3 , 4);
358 TESTINST4("beq", 1, 1, 1, 3, 4, 5);
359 TESTINST4("beq", 2, 0xffffffff, 0xffffffff, 4, 5, 6);
360 TESTINST4("beq", 3, 0xffffffff, 0xfffffffe, 5, 6, 7);
361 TESTINST4("beq", 4, 0xfffffffe, 0xffffffff, 6, 8, 9);
362 TESTINST4("beq", 5, 0xffffffff, 0xffffffff, 7, 8, 9);
363 TESTINST4("beq", 6, 0x5, 0x5, 8, 9, 10);
364 TESTINST4("beq", 7, -3, -4, 9, 10, 11);
365 TESTINST4("beq", 8, 125, 125, 10, 11, 12);
366 TESTINST4("beq", 9, 0x80000000, 0x80000000, 11, 12, 13);
367 TESTINST4("beq", 10, 0xffffffff, 0x80000000, 12, 13, 14);
368 TESTINST4("beq", 11, 0x256, 0x256, 13, 14, 15);
369 TESTINST4("beq", 12, 0x55, 0x55, 14, 15, 16);
370 TESTINST4("beq", 13, 0xfff, 0xdd, 16, 17, 18);
371 TESTINST4("beq", 14, -1, 0x5, 2, 25, 24);
372 TESTINST4("beq", 15, -1, -1, 25, 24, 7);
373
374 printf("--- BNE --- if RSval != RTval then " \
375 "out = RDval + 1 else out = RDval + 6\n");
376 TESTINST4("bne", 0, 0, 1, 2, 3, 4);
377 TESTINST4("bne", 1, 1, 1, 3, 4, 5);
378 TESTINST4("bne", 2, 0xffffffff, 0xffffffff, 4, 5, 6);
379 TESTINST4("bne", 3, 0xffffffff, 0xfffffffe, 5, 6, 7);
380 TESTINST4("bne", 4, 0xfffffffe, 0xffffffff, 6, 8, 9);
381 TESTINST4("bne", 5, 0xffffffff, 0xffffffff, 7, 8, 9);
382 TESTINST4("bne", 6, 0x5, 0x5, 8, 9, 10);
383 TESTINST4("bne", 7, -3, -4, 9, 10, 11);
384 TESTINST4("bne", 8, 125, 125, 10, 11, 12);
385 TESTINST4("bne", 9, 0x80000000, 0x80000000, 11, 12, 13);
386 TESTINST4("bne", 10, 0xffffffff, 0x80000000, 12, 13, 14);
387 TESTINST4("bne", 11, 0x256, 0x256, 13, 14, 15);
388 TESTINST4("bne", 12, 0x55, 0x55, 14, 15, 16);
389 TESTINST4("bne", 13, 0xfff, 0xdd, 16, 17, 18);
390 TESTINST4("bne", 14, -1, 0x5, 2, 25, 24);
391 TESTINST4("bne", 15, -1, -1, 25, 24, 7);
392
393 printf("--- BEQZ --- if RSval == 0 then " \
394 "out = RDval + 1 else out = RDval + 6\n");
395 TESTINST5("beqz", 0, 0, 2, 3);
396 TESTINST5("beqz", 1, 1, 3, 4);
397 TESTINST5("beqz", 2, 0xffffffff, 4, 5);
398 TESTINST5("beqz", 3, 0xffffffff, 5, 6);
399 TESTINST5("beqz", 4, 0xfffffffe, 6, 8);
400 TESTINST5("beqz", 5, 0xffffffff, 7, 8);
401 TESTINST5("beqz", 6, 0x5, 8, 9);
402 TESTINST5("beqz", 7, -3, 9, 10);
403 TESTINST5("beqz", 8, 125, 10, 11);
404 TESTINST5("beqz", 9, 0x80000000, 11, 12);
405 TESTINST5("beqz", 10, 0xffffffff, 12, 13);
406 TESTINST5("beqz", 11, 0x256, 13, 14);
407 TESTINST5("beqz", 12, 0x55, 14, 15);
408 TESTINST5("beqz", 13, 0xfff, 16, 17);
409 TESTINST5("beqz", 14, -1, 2, 25);
410 TESTINST5("beqz", 15, -1, 25, 24);
411
412 printf("--- BGEZ --- if RSval >= 0 then " \
413 "out = RDval + 1 else out = RDval + 6\n");
414 TESTINST5("bgez", 0, 0, 2, 3);
415 TESTINST5("bgez", 1, 1, 3, 4);
416 TESTINST5("bgez", 2, 0xffffffff, 4, 5);
417 TESTINST5("bgez", 3, 0xffffffff, 5, 6);
418 TESTINST5("bgez", 4, 0xfffffffe, 6, 8);
419 TESTINST5("bgez", 5, 0xffffffff, 7, 8);
420 TESTINST5("bgez", 6, 0x5, 8, 9);
421 TESTINST5("bgez", 7, -3, 9, 10);
422 TESTINST5("bgez", 8, 125, 10, 11);
423 TESTINST5("bgez", 9, 0x80000000, 11, 12);
424 TESTINST5("bgez", 10, 0xffffffff, 12, 13);
425 TESTINST5("bgez", 11, 0x256, 13, 14);
426 TESTINST5("bgez", 12, 0x55, 14, 15);
427 TESTINST5("bgez", 13, 0xfff, 16, 17);
428 TESTINST5("bgez", 14, -1, 2, 25);
429 TESTINST5("bgez", 15, -1, 25, 24);
430
431 printf("--- BGTZ --- if RSval > 0 then " \
432 "out = RDval + 1 else out = RDval + 6\n");
433 TESTINST5("bgtz", 0, 0, 2, 3);
434 TESTINST5("bgtz", 1, 1, 3, 4);
435 TESTINST5("bgtz", 2, 0xffffffff, 4, 5);
436 TESTINST5("bgtz", 3, 0xffffffff, 5, 6);
437 TESTINST5("bgtz", 4, 0xfffffffe, 6, 8);
438 TESTINST5("bgtz", 5, 0xffffffff, 7, 8);
439 TESTINST5("bgtz", 6, 0x5, 8, 9);
440 TESTINST5("bgtz", 7, -3, 9, 10);
441 TESTINST5("bgtz", 8, 125, 10, 11);
442 TESTINST5("bgtz", 9, 0x80000000, 11, 12);
443 TESTINST5("bgtz", 10, 0xffffffff, 12, 13);
444 TESTINST5("bgtz", 11, 0x256, 13, 14);
445 TESTINST5("bgtz", 12, 0x55, 14, 15);
446 TESTINST5("bgtz", 13, 0xfff, 16, 17);
447 TESTINST5("bgtz", 14, -1, 2, 25);
448 TESTINST5("bgtz", 15, -1, 25, 24);
449
450 printf("--- BLEZ --- if RSval <= 0 then " \
451 "out = RDval + 1 else out = RDval + 6\n");
452 TESTINST5("blez", 0, 0, 2, 3);
453 TESTINST5("blez", 1, 1, 3, 4);
454 TESTINST5("blez", 2, 0xffffffff, 4, 5);
455 TESTINST5("blez", 3, 0xffffffff, 5, 6);
456 TESTINST5("blez", 4, 0xfffffffe, 6, 8);
457 TESTINST5("blez", 5, 0xffffffff, 7, 8);
458 TESTINST5("blez", 6, 0x5, 8, 9);
459 TESTINST5("blez", 7, -3, 9, 10);
460 TESTINST5("blez", 8, 125, 10, 11);
461 TESTINST5("blez", 9, 0x80000000, 11, 12);
462 TESTINST5("blez", 10, 0xffffffff, 12, 13);
463 TESTINST5("blez", 11, 0x256, 13, 14);
464 TESTINST5("blez", 12, 0x55, 14, 15);
465 TESTINST5("blez", 13, 0xfff, 16, 17);
466 TESTINST5("blez", 14, -1, 2, 25);
467 TESTINST5("blez", 15, -1, 25, 24);
468
469 printf("--- BLTZ --- if RSval < 0 then " \
470 "out = RDval + 1 else out = RDval + 6\n");
471 TESTINST5("bltz", 0, 0, 2, 3);
472 TESTINST5("bltz", 1, 1, 3, 4);
473 TESTINST5("bltz", 2, 0xffffffff, 4, 5);
474 TESTINST5("bltz", 3, 0xffffffff, 5, 6);
475 TESTINST5("bltz", 4, 0xfffffffe, 6, 8);
476 TESTINST5("bltz", 5, 0xffffffff, 7, 8);
477 TESTINST5("bltz", 6, 0x5, 8, 9);
478 TESTINST5("bltz", 7, -3, 9, 10);
479 TESTINST5("bltz", 8, 125, 10, 11);
480 TESTINST5("bltz", 9, 0x80000000, 11, 12);
481 TESTINST5("bltz", 10, 0xffffffff, 12, 13);
482 TESTINST5("bltz", 11, 0x256, 13, 14);
483 TESTINST5("bltz", 12, 0x55, 14, 15);
484 TESTINST5("bltz", 13, 0xfff, 16, 17);
485 TESTINST5("bltz", 14, -1, 2, 25);
486 TESTINST5("bltz", 15, -1, 25, 24);
487 #if (__mips_isa_rev < 6)
488 printf("--- BGEZAL --- if RSval >= 0 then " \
489 "out = RDval + 6 else out = RDval + 5\n");
490 TESTINST6("bgezal", 0, 0, 2, 3);
491 TESTINST6("bgezal", 1, 1, 3, 4);
492 TESTINST6("bgezal", 2, 0xffffffff, 4, 5);
493 TESTINST6("bgezal", 3, 0xffffffff, 5, 6);
494 TESTINST6("bgezal", 4, 0xfffffffe, 6, 8);
495 TESTINST6("bgezal", 5, 0xffffffff, 7, 8);
496 TESTINST6("bgezal", 6, 0x5, 8, 9);
497 TESTINST6("bgezal", 7, -3, 9, 10);
498 TESTINST6("bgezal", 8, 125, 10, 11);
499 TESTINST6("bgezal", 9, 0x80000000, 11, 12);
500 TESTINST6("bgezal", 10, 0xffffffff, 12, 13);
501 TESTINST6("bgezal", 11, 0x256, 13, 14);
502 TESTINST6("bgezal", 12, 0x55, 14, 15);
503 TESTINST6("bgezal", 13, 0xfff, 16, 17);
504 TESTINST6("bgezal", 14, -1, 2, 25);
505 TESTINST6("bgezal", 15, -1, 25, 24);
506
507 printf("--- BLTZAL --- if RSval < 0 then " \
508 "out = RDval + 6 else out = RDval + 5\n");
509 TESTINST6("bltzal", 0, 0, 2, 3);
510 TESTINST6("bltzal", 1, 1, 3, 4);
511 TESTINST6("bltzal", 2, 0xffffffff, 4, 5);
512 TESTINST6("bltzal", 3, 0xffffffff, 5, 6);
513 TESTINST6("bltzal", 4, 0xfffffffe, 6, 8);
514 TESTINST6("bltzal", 5, 0xffffffff, 7, 8);
515 TESTINST6("bltzal", 6, 0x5, 8, 9);
516 TESTINST6("bltzal", 7, -3, 9, 10);
517 TESTINST6("bltzal", 8, 125, 10, 11);
518 TESTINST6("bltzal", 9, 0x80000000, 11, 12);
519 TESTINST6("bltzal", 10, 0xffffffff, 12, 13);
520 TESTINST6("bltzal", 11, 0x256, 13, 14);
521 TESTINST6("bltzal", 12, 0x55, 14, 15);
522 TESTINST6("bltzal", 13, 0xfff, 16, 17);
523 TESTINST6("bltzal", 14, -1, 2, 25);
524 TESTINST6("bltzal", 15, -1, 25, 24);
525 #endif
526 printf("--- BNEZ --- if RSval != 0 then " \
527 "out = RDval + 1 else out = RDval + 6\n");
528 TESTINST5("bnez", 0, 0, 2, 3);
529 TESTINST5("bnez", 1, 1, 3, 4);
530 TESTINST5("bnez", 2, 0xffffffff, 4, 5);
531 TESTINST5("bnez", 3, 0xffffffff, 5, 6);
532 TESTINST5("bnez", 4, 0xfffffffe, 6, 8);
533 TESTINST5("bnez", 5, 0xffffffff, 7, 8);
534 TESTINST5("bnez", 6, 0x5, 8, 9);
535 TESTINST5("bnez", 7, -3, 9, 10);
536 TESTINST5("bnez", 8, 125, 10, 11);
537 TESTINST5("bnez", 9, 0x80000000, 11, 12);
538 TESTINST5("bnez", 10, 0xffffffff, 12, 13);
539 TESTINST5("bnez", 11, 0x256, 13, 14);
540 TESTINST5("bnez", 12, 0x55, 14, 15);
541 TESTINST5("bnez", 13, 0xfff, 16, 17);
542 TESTINST5("bnez", 14, -1, 2, 25);
543 TESTINST5("bnez", 15, -1, 25, 24);
544 #if (__mips_isa_rev < 6)
545 printf("--- BEQL --- if RSval == RTval then " \
546 "out = RDval + 4 else out = RDval + 6\n");
547 TESTINST4l("beql", 0, 0, 1, 2, 3, 4);
548 TESTINST4l("beql", 1, 1, 1, 3, 4, 5);
549 TESTINST4l("beql", 2, 0xffffffff, 0xffffffff, 4, 5, 6);
550 TESTINST4l("beql", 3, 0xffffffff, 0xfffffffe, 5, 6, 7);
551 TESTINST4l("beql", 4, 0xfffffffe, 0xffffffff, 6, 8, 9);
552 TESTINST4l("beql", 5, 0xffffffff, 0xffffffff, 7, 8, 9);
553 TESTINST4l("beql", 6, 0x5, 0x5, 8, 9, 10);
554 TESTINST4l("beql", 7, -3, -4, 9, 10, 11);
555 TESTINST4l("beql", 8, 125, 125, 10, 11, 12);
556 TESTINST4l("beql", 9, 0x80000000, 0x80000000, 11, 12, 13);
557 TESTINST4l("beql", 10, 0xffffffff, 0x80000000, 12, 13, 14);
558 TESTINST4l("beql", 11, 0x256, 0x256, 13, 14, 15);
559 TESTINST4l("beql", 12, 0x55, 0x55, 14, 15, 16);
560 TESTINST4l("beql", 13, 0xfff, 0xdd, 16, 17, 18);
561 TESTINST4l("beql", 14, -1, 0x5, 2, 25, 24);
562 TESTINST4l("beql", 15, -1, -1, 25, 24, 7);
563
564 printf("--- BGEZALL --- if RSval >= 0 then " \
565 "out = RDval + 4 else out = RDval + 6\n");
566 TESTINST5l("bgezall", 0, 0, 2, 3);
567 TESTINST5l("bgezall", 1, 1, 3, 4);
568 TESTINST5l("bgezall", 2, 0xffffffff, 4, 5);
569 TESTINST5l("bgezall", 3, 0xffffffff, 5, 6);
570 TESTINST5l("bgezall", 4, 0xfffffffe, 6, 8);
571 TESTINST5l("bgezall", 5, 0xffffffff, 7, 8);
572 TESTINST5l("bgezall", 6, 0x5, 8, 9);
573 TESTINST5l("bgezall", 7, -3, 9, 10);
574 TESTINST5l("bgezall", 8, 125, 10, 11);
575 TESTINST5l("bgezall", 9, 0x80000000, 11, 12);
576 TESTINST5l("bgezall", 10, 0xffffffff, 12, 13);
577 TESTINST5l("bgezall", 11, 0x256, 13, 14);
578 TESTINST5l("bgezall", 12, 0x55, 14, 15);
579 TESTINST5l("bgezall", 13, 0xfff, 16, 17);
580 TESTINST5l("bgezall", 14, -1, 2, 25);
581 TESTINST5l("bgezall", 15, -1, 25, 24);
582
583 printf("--- BLTZALL --- if RSval < 0 then " \
584 "out = RDval + 4 else out = RDval + 6\n");
585 TESTINST5l("bltzall", 0, 0, 2, 3);
586 TESTINST5l("bltzall", 1, 1, 3, 4);
587 TESTINST5l("bltzall", 2, 0xffffffff, 4, 5);
588 TESTINST5l("bltzall", 3, 0xffffffff, 5, 6);
589 TESTINST5l("bltzall", 4, 0xfffffffe, 6, 8);
590 TESTINST5l("bltzall", 5, 0xffffffff, 7, 8);
591 TESTINST5l("bltzall", 6, 0x5, 8, 9);
592 TESTINST5l("bltzall", 7, -3, 9, 10);
593 TESTINST5l("bltzall", 8, 125, 10, 11);
594 TESTINST5l("bltzall", 9, 0x80000000, 11, 12);
595 TESTINST5l("bltzall", 10, 0xffffffff, 12, 13);
596 TESTINST5l("bltzall", 11, 0x256, 13, 14);
597 TESTINST5l("bltzall", 12, 0x55, 14, 15);
598 TESTINST5l("bltzall", 13, 0xfff, 16, 17);
599 TESTINST5l("bltzall", 14, -1, 2, 25);
600 TESTINST5l("bltzall", 15, -1, 25, 24);
601
602 printf("--- BGEZL --- if RSval >= 0 then " \
603 "out = RDval + 4 else out = RDval + 6\n");
604 TESTINST5l("bgezl", 0, 0, 2, 3);
605 TESTINST5l("bgezl", 1, 1, 3, 4);
606 TESTINST5l("bgezl", 2, 0xffffffff, 4, 5);
607 TESTINST5l("bgezl", 3, 0xffffffff, 5, 6);
608 TESTINST5l("bgezl", 4, 0xfffffffe, 6, 8);
609 TESTINST5l("bgezl", 5, 0xffffffff, 7, 8);
610 TESTINST5l("bgezl", 6, 0x5, 8, 9);
611 TESTINST5l("bgezl", 7, -3, 9, 10);
612 TESTINST5l("bgezl", 8, 125, 10, 11);
613 TESTINST5l("bgezl", 9, 0x80000000, 11, 12);
614 TESTINST5l("bgezl", 10, 0xffffffff, 12, 13);
615 TESTINST5l("bgezl", 11, 0x256, 13, 14);
616 TESTINST5l("bgezl", 12, 0x55, 14, 15);
617 TESTINST5l("bgezl", 13, 0xfff, 16, 17);
618 TESTINST5l("bgezl", 14, -1, 2, 25);
619 TESTINST5l("bgezl", 15, -1, 25, 24);
620
621 printf("--- BGTZL --- if RSval > 0 then " \
622 "out = RDval + 4 else out = RDval + 6\n");
623 TESTINST5l("bgtzl", 0, 0, 2, 3);
624 TESTINST5l("bgtzl", 1, 1, 3, 4);
625 TESTINST5l("bgtzl", 2, 0xffffffff, 4, 5);
626 TESTINST5l("bgtzl", 3, 0xffffffff, 5, 6);
627 TESTINST5l("bgtzl", 4, 0xfffffffe, 6, 8);
628 TESTINST5l("bgtzl", 5, 0xffffffff, 7, 8);
629 TESTINST5l("bgtzl", 6, 0x5, 8, 9);
630 TESTINST5l("bgtzl", 7, -3, 9, 10);
631 TESTINST5l("bgtzl", 8, 125, 10, 11);
632 TESTINST5l("bgtzl", 9, 0x80000000, 11, 12);
633 TESTINST5l("bgtzl", 10, 0xffffffff, 12, 13);
634 TESTINST5l("bgtzl", 11, 0x256, 13, 14);
635 TESTINST5l("bgtzl", 12, 0x55, 14, 15);
636 TESTINST5l("bgtzl", 13, 0xfff, 16, 17);
637 TESTINST5l("bgtzl", 14, -1, 2, 25);
638 TESTINST5l("bgtzl", 15, -1, 25, 24);
639
640 printf("--- BLEZL --- if RSval <= 0 then " \
641 "out = RDval + 4 else out = RDval + 6\n");
642 TESTINST5l("blezl", 0, 0, 2, 3);
643 TESTINST5l("blezl", 1, 1, 3, 4);
644 TESTINST5l("blezl", 2, 0xffffffff, 4, 5);
645 TESTINST5l("blezl", 3, 0xffffffff, 5, 6);
646 TESTINST5l("blezl", 4, 0xfffffffe, 6, 8);
647 TESTINST5l("blezl", 5, 0xffffffff, 7, 8);
648 TESTINST5l("blezl", 6, 0x5, 8, 9);
649 TESTINST5l("blezl", 7, -3, 9, 10);
650 TESTINST5l("blezl", 8, 125, 10, 11);
651 TESTINST5l("blezl", 9, 0x80000000, 11, 12);
652 TESTINST5l("blezl", 10, 0xffffffff, 12, 13);
653 TESTINST5l("blezl", 11, 0x256, 13, 14);
654 TESTINST5l("blezl", 12, 0x55, 14, 15);
655 TESTINST5l("blezl", 13, 0xfff, 16, 17);
656 TESTINST5l("blezl", 14, -1, 2, 25);
657 TESTINST5l("blezl", 15, -1, 25, 24);
658
659 printf("--- BGEZALL --- if RSval >= 0 then " \
660 "out = RDval + 9 else out = RDval + 5\n");
661 TESTINST6l("bgezall", 0, 0, 2, 3);
662 TESTINST6l("bgezall", 1, 1, 3, 4);
663 TESTINST6l("bgezall", 2, 0xffffffff, 4, 5);
664 TESTINST6l("bgezall", 3, 0xffffffff, 5, 6);
665 TESTINST6l("bgezall", 4, 0xfffffffe, 6, 8);
666 TESTINST6l("bgezall", 5, 0xffffffff, 7, 8);
667 TESTINST6l("bgezall", 6, 0x5, 8, 9);
668 TESTINST6l("bgezall", 7, -3, 9, 10);
669 TESTINST6l("bgezall", 8, 125, 10, 11);
670 TESTINST6l("bgezall", 9, 0x80000000, 11, 12);
671 TESTINST6l("bgezall", 10, 0xffffffff, 12, 13);
672 TESTINST6l("bgezall", 11, 0x256, 13, 14);
673 TESTINST6l("bgezall", 12, 0x55, 14, 15);
674 TESTINST6l("bgezall", 13, 0xfff, 16, 17);
675 TESTINST6l("bgezall", 14, -1, 2, 25);
676 TESTINST6l("bgezall", 15, -1, 25, 24);
677
678 printf("--- BLTZL --- if RSval < 0 then " \
679 "out = RDval + 4 else out = RDval + 6\n");
680 TESTINST5l("bltzl", 0, 0, 2, 3);
681 TESTINST5l("bltzl", 1, 1, 3, 4);
682 TESTINST5l("bltzl", 2, 0xffffffff, 4, 5);
683 TESTINST5l("bltzl", 3, 0xffffffff, 5, 6);
684 TESTINST5l("bltzl", 4, 0xfffffffe, 6, 8);
685 TESTINST5l("bltzl", 5, 0xffffffff, 7, 8);
686 TESTINST5l("bltzl", 6, 0x5, 8, 9);
687 TESTINST5l("bltzl", 7, -3, 9, 10);
688 TESTINST5l("bltzl", 8, 125, 10, 11);
689 TESTINST5l("bltzl", 9, 0x80000000, 11, 12);
690 TESTINST5l("bltzl", 10, 0xffffffff, 12, 13);
691 TESTINST5l("bltzl", 11, 0x256, 13, 14);
692 TESTINST5l("bltzl", 12, 0x55, 14, 15);
693 TESTINST5l("bltzl", 13, 0xfff, 16, 17);
694 TESTINST5l("bltzl", 14, -1, 2, 25);
695 TESTINST5l("bltzl", 15, -1, 25, 24);
696
697 printf("--- BNEL --- if RSval != RTval then " \
698 "out = RDval + 4 else out = RDval + 5\n");
699 TESTINST4l("bnel", 0, 0, 1, 2, 3, 4);
700 TESTINST4l("bnel", 1, 1, 1, 3, 4, 5);
701 TESTINST4l("bnel", 2, 0xffffffff, 0xffffffff, 4, 5, 6);
702 TESTINST4l("bnel", 3, 0xffffffff, 0xfffffffe, 5, 6, 7);
703 TESTINST4l("bnel", 4, 0xfffffffe, 0xffffffff, 6, 8, 9);
704 TESTINST4l("bnel", 5, 0xffffffff, 0xffffffff, 7, 8, 9);
705 TESTINST4l("bnel", 6, 0x5, 0x5, 8, 9, 10);
706 TESTINST4l("bnel", 7, -3, -4, 9, 10, 11);
707 TESTINST4l("bnel", 8, 125, 125, 10, 11, 12);
708 TESTINST4l("bnel", 9, 0x80000000, 0x80000000, 11, 12, 13);
709 TESTINST4l("bnel", 10, 0xffffffff, 0x80000000, 12, 13, 14);
710 TESTINST4l("bnel", 11, 0x256, 0x256, 13, 14, 15);
711 TESTINST4l("bnel", 12, 0x55, 0x55, 14, 15, 16);
712 TESTINST4l("bnel", 13, 0xfff, 0xdd, 16, 17, 18);
713 TESTINST4l("bnel", 14, -1, 0x5, 2, 25, 24);
714 TESTINST4l("bnel", 15, -1, -1, 25, 24, 7);
715 #endif
716 printf("j, jal, jr\n");
717 TESTINST3j(0, 2);
718 TESTINST3j(1, 3);
719 TESTINST3j(2, 4);
720 TESTINST3j(3, 5);
721 TESTINST3j(4, 6);
722 TESTINST3j(5, 7);
723 TESTINST3j(6, 4);
724 TESTINST3j(7, 9);
725 TESTINST3j(8, 10);
726 TESTINST3j(9, 11);
727 TESTINST3j(10, 12);
728 TESTINST3j(11, 13);
729 TESTINST3j(12, 14);
730 TESTINST3j(13, 15);
731 TESTINST3j(14, 16);
732 TESTINST3j(15, 17);
733 TESTINST3j(16, 18);
734 TESTINST3j(17, 19);
735 TESTINST3j(18, 20);
736 TESTINST3j(19, 21);
737 TESTINST3j(20, 22);
738 TESTINST3j(21, 23);
739 TESTINST3j(22, 24);
740 TESTINST3j(23, 24);
741
742 printf("j, jalr, jr\n");
743 TESTINST3ja(0, 2);
744 TESTINST3ja(1, 3);
745 TESTINST3ja(2, 4);
746 TESTINST3ja(3, 5);
747 TESTINST3ja(4, 6);
748 TESTINST3ja(5, 7);
749 TESTINST3ja(6, 4);
750 TESTINST3ja(7, 7);
751 TESTINST3ja(8, 10);
752 TESTINST3ja(9, 11);
753 TESTINST3ja(11, 13);
754 TESTINST3ja(12, 14);
755 TESTINST3ja(13, 15);
756 TESTINST3ja(14, 16);
757 TESTINST3ja(15, 17);
758 TESTINST3ja(16, 18);
759 TESTINST3ja(17, 19);
760 TESTINST3ja(18, 20);
761 TESTINST3ja(19, 21);
762 TESTINST3ja(20, 22);
763 TESTINST3ja(21, 23);
764 TESTINST3ja(22, 24);
765 TESTINST3ja(23, 24);
766
767 return 0;
768 }
769