?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make UEFI boot-platform build again
[haiku.git] / src / libs / x86emu / validate.c
blob4c36e1df51c50826eeaf4ee52727ebd6663e788e
1 /****************************************************************************
2 *
3 * Realmode X86 Emulator Library
4 *
5 * Copyright (C) 1996-1999 SciTech Software, Inc.
6 * Copyright (C) David Mosberger-Tang
7 * Copyright (C) 1999 Egbert Eich
8 *
9 * ========================================================================
10 *
11 * Permission to use, copy, modify, distribute, and sell this software and
12 * its documentation for any purpose is hereby granted without fee,
13 * provided that the above copyright notice appear in all copies and that
14 * both that copyright notice and this permission notice appear in
15 * supporting documentation, and that the name of the authors not be used
16 * in advertising or publicity pertaining to distribution of the software
17 * without specific, written prior permission. The authors makes no
18 * representations about the suitability of this software for any purpose.
19 * It is provided "as is" without express or implied warranty.
20 *
21 * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
22 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
23 * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
24 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
25 * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
26 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
27 * PERFORMANCE OF THIS SOFTWARE.
28 *
29 * ========================================================================
30 *
31 * Language: Watcom C 10.6 or later
32 * Environment: 32-bit DOS
33 * Developer: Kendall Bennett
34 *
35 * Description: Program to validate the x86 emulator library for
36 * correctness. We run the emulator primitive operations
37 * functions against the real x86 CPU, and compare the result
38 * and flags to ensure correctness.
39 *
40 * We use inline assembler to compile and build this program.
41 *
42 ****************************************************************************/
43
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <stdarg.h>
48 #include "x86emu.h"
49 #include "x86emu/prim_asm.h"
50
51 /*-------------------------- Implementation -------------------------------*/
52
53 #define true 1
54 #define false 0
55
56 #define ALL_FLAGS (F_CF | F_PF | F_AF | F_ZF | F_SF | F_OF)
57
58 #define VAL_START_BINARY(parm_type,res_type,dmax,smax,dincr,sincr) \
59 { \
60 parm_type d,s; \
61 res_type r,r_asm; \
62 ulong flags,inflags; \
63 int f,failed = false; \
64 char buf1[80],buf2[80]; \
65 for (d = 0; d < dmax; d += dincr) { \
66 for (s = 0; s < smax; s += sincr) { \
67 M.x86.R_EFLG = inflags = flags = def_flags; \
68 for (f = 0; f < 2; f++) {
69
70 #define VAL_TEST_BINARY(name) \
71 r_asm = name##_asm(&flags,d,s); \
72 r = name(d,s); \
73 if (r != r_asm || M.x86.R_EFLG != flags) \
74 failed = true; \
75 if (failed || trace) {
76
77 #define VAL_TEST_BINARY_VOID(name) \
78 name##_asm(&flags,d,s); \
79 name(d,s); \
80 r = r_asm = 0; \
81 if (M.x86.R_EFLG != flags) \
82 failed = true; \
83 if (failed || trace) {
84
85 #define VAL_FAIL_BYTE_BYTE_BINARY(name) \
86 if (failed) \
87 printk("fail\n"); \
88 printk("0x%02X = %-15s(0x%02X,0x%02X), flags = %s -> %s\n", \
89 r, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
90 printk("0x%02X = %-15s(0x%02X,0x%02X), flags = %s -> %s\n", \
91 r_asm, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));
92
93 #define VAL_FAIL_WORD_WORD_BINARY(name) \
94 if (failed) \
95 printk("fail\n"); \
96 printk("0x%04X = %-15s(0x%04X,0x%04X), flags = %s -> %s\n", \
97 r, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
98 printk("0x%04X = %-15s(0x%04X,0x%04X), flags = %s -> %s\n", \
99 r_asm, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));
100
101 #define VAL_FAIL_LONG_LONG_BINARY(name) \
102 if (failed) \
103 printk("fail\n"); \
104 printk("0x%08X = %-15s(0x%08X,0x%08X), flags = %s -> %s\n", \
105 r, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
106 printk("0x%08X = %-15s(0x%08X,0x%08X), flags = %s -> %s\n", \
107 r_asm, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));
108
109 #define VAL_END_BINARY() \
110 } \
111 M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF); \
112 if (failed) \
113 break; \
114 } \
115 if (failed) \
116 break; \
117 } \
118 if (failed) \
119 break; \
120 } \
121 if (!failed) \
122 printk("passed\n"); \
123 }
124
125 #define VAL_BYTE_BYTE_BINARY(name) \
126 printk("Validating %s ... ", #name); \
127 VAL_START_BINARY(u8,u8,0xFF,0xFF,1,1) \
128 VAL_TEST_BINARY(name) \
129 VAL_FAIL_BYTE_BYTE_BINARY(name) \
130 VAL_END_BINARY()
131
132 #define VAL_WORD_WORD_BINARY(name) \
133 printk("Validating %s ... ", #name); \
134 VAL_START_BINARY(u16,u16,0xFF00,0xFF00,0x100,0x100) \
135 VAL_TEST_BINARY(name) \
136 VAL_FAIL_WORD_WORD_BINARY(name) \
137 VAL_END_BINARY()
138
139 #define VAL_LONG_LONG_BINARY(name) \
140 printk("Validating %s ... ", #name); \
141 VAL_START_BINARY(u32,u32,0xFF000000,0xFF000000,0x1000000,0x1000000) \
142 VAL_TEST_BINARY(name) \
143 VAL_FAIL_LONG_LONG_BINARY(name) \
144 VAL_END_BINARY()
145
146 #define VAL_VOID_BYTE_BINARY(name) \
147 printk("Validating %s ... ", #name); \
148 VAL_START_BINARY(u8,u8,0xFF,0xFF,1,1) \
149 VAL_TEST_BINARY_VOID(name) \
150 VAL_FAIL_BYTE_BYTE_BINARY(name) \
151 VAL_END_BINARY()
152
153 #define VAL_VOID_WORD_BINARY(name) \
154 printk("Validating %s ... ", #name); \
155 VAL_START_BINARY(u16,u16,0xFF00,0xFF00,0x100,0x100) \
156 VAL_TEST_BINARY_VOID(name) \
157 VAL_FAIL_WORD_WORD_BINARY(name) \
158 VAL_END_BINARY()
159
160 #define VAL_VOID_LONG_BINARY(name) \
161 printk("Validating %s ... ", #name); \
162 VAL_START_BINARY(u32,u32,0xFF000000,0xFF000000,0x1000000,0x1000000) \
163 VAL_TEST_BINARY_VOID(name) \
164 VAL_FAIL_LONG_LONG_BINARY(name) \
165 VAL_END_BINARY()
166
167 #define VAL_BYTE_ROTATE(name) \
168 printk("Validating %s ... ", #name); \
169 VAL_START_BINARY(u8,u8,0xFF,8,1,1) \
170 VAL_TEST_BINARY(name) \
171 VAL_FAIL_BYTE_BYTE_BINARY(name) \
172 VAL_END_BINARY()
173
174 #define VAL_WORD_ROTATE(name) \
175 printk("Validating %s ... ", #name); \
176 VAL_START_BINARY(u16,u16,0xFF00,16,0x100,1) \
177 VAL_TEST_BINARY(name) \
178 VAL_FAIL_WORD_WORD_BINARY(name) \
179 VAL_END_BINARY()
180
181 #define VAL_LONG_ROTATE(name) \
182 printk("Validating %s ... ", #name); \
183 VAL_START_BINARY(u32,u32,0xFF000000,32,0x1000000,1) \
184 VAL_TEST_BINARY(name) \
185 VAL_FAIL_LONG_LONG_BINARY(name) \
186 VAL_END_BINARY()
187
188 #define VAL_START_TERNARY(parm_type,res_type,dmax,smax,dincr,sincr,maxshift)\
189 { \
190 parm_type d,s; \
191 res_type r,r_asm; \
192 u8 shift; \
193 u32 flags,inflags; \
194 int f,failed = false; \
195 char buf1[80],buf2[80]; \
196 for (d = 0; d < dmax; d += dincr) { \
197 for (s = 0; s < smax; s += sincr) { \
198 for (shift = 0; shift < maxshift; shift += 1) { \
199 M.x86.R_EFLG = inflags = flags = def_flags; \
200 for (f = 0; f < 2; f++) {
201
202 #define VAL_TEST_TERNARY(name) \
203 r_asm = name##_asm(&flags,d,s,shift); \
204 r = name(d,s,shift); \
205 if (r != r_asm || M.x86.R_EFLG != flags) \
206 failed = true; \
207 if (failed || trace) {
208
209 #define VAL_FAIL_WORD_WORD_TERNARY(name) \
210 if (failed) \
211 printk("fail\n"); \
212 printk("0x%04X = %-15s(0x%04X,0x%04X,%d), flags = %s -> %s\n", \
213 r, #name, d, s, shift, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
214 printk("0x%04X = %-15s(0x%04X,0x%04X,%d), flags = %s -> %s\n", \
215 r_asm, #name"_asm", d, s, shift, print_flags(buf1,inflags), print_flags(buf2,flags));
216
217 #define VAL_FAIL_LONG_LONG_TERNARY(name) \
218 if (failed) \
219 printk("fail\n"); \
220 printk("0x%08X = %-15s(0x%08X,0x%08X,%d), flags = %s -> %s\n", \
221 r, #name, d, s, shift, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
222 printk("0x%08X = %-15s(0x%08X,0x%08X,%d), flags = %s -> %s\n", \
223 r_asm, #name"_asm", d, s, shift, print_flags(buf1,inflags), print_flags(buf2,flags));
224
225 #define VAL_END_TERNARY() \
226 } \
227 M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF); \
228 if (failed) \
229 break; \
230 } \
231 if (failed) \
232 break; \
233 } \
234 if (failed) \
235 break; \
236 } \
237 if (failed) \
238 break; \
239 } \
240 if (!failed) \
241 printk("passed\n"); \
242 }
243
244 #define VAL_WORD_ROTATE_DBL(name) \
245 printk("Validating %s ... ", #name); \
246 VAL_START_TERNARY(u16,u16,0xFF00,0xFF00,0x100,0x100,16) \
247 VAL_TEST_TERNARY(name) \
248 VAL_FAIL_WORD_WORD_TERNARY(name) \
249 VAL_END_TERNARY()
250
251 #define VAL_LONG_ROTATE_DBL(name) \
252 printk("Validating %s ... ", #name); \
253 VAL_START_TERNARY(u32,u32,0xFF000000,0xFF000000,0x1000000,0x1000000,32) \
254 VAL_TEST_TERNARY(name) \
255 VAL_FAIL_LONG_LONG_TERNARY(name) \
256 VAL_END_TERNARY()
257
258 #define VAL_START_UNARY(parm_type,max,incr) \
259 { \
260 parm_type d,r,r_asm; \
261 u32 flags,inflags; \
262 int f,failed = false; \
263 char buf1[80],buf2[80]; \
264 for (d = 0; d < max; d += incr) { \
265 M.x86.R_EFLG = inflags = flags = def_flags; \
266 for (f = 0; f < 2; f++) {
267
268 #define VAL_TEST_UNARY(name) \
269 r_asm = name##_asm(&flags,d); \
270 r = name(d); \
271 if (r != r_asm || M.x86.R_EFLG != flags) { \
272 failed = true;
273
274 #define VAL_FAIL_BYTE_UNARY(name) \
275 printk("fail\n"); \
276 printk("0x%02X = %-15s(0x%02X), flags = %s -> %s\n", \
277 r, #name, d, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
278 printk("0x%02X = %-15s(0x%02X), flags = %s -> %s\n", \
279 r_asm, #name"_asm", d, print_flags(buf1,inflags), print_flags(buf2,flags));
280
281 #define VAL_FAIL_WORD_UNARY(name) \
282 printk("fail\n"); \
283 printk("0x%04X = %-15s(0x%04X), flags = %s -> %s\n", \
284 r, #name, d, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
285 printk("0x%04X = %-15s(0x%04X), flags = %s -> %s\n", \
286 r_asm, #name"_asm", d, print_flags(buf1,inflags), print_flags(buf2,flags));
287
288 #define VAL_FAIL_LONG_UNARY(name) \
289 printk("fail\n"); \
290 printk("0x%08X = %-15s(0x%08X), flags = %s -> %s\n", \
291 r, #name, d, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
292 printk("0x%08X = %-15s(0x%08X), flags = %s -> %s\n", \
293 r_asm, #name"_asm", d, print_flags(buf1,inflags), print_flags(buf2,flags));
294
295 #define VAL_END_UNARY() \
296 } \
297 M.x86.R_EFLG = inflags = flags = def_flags | ALL_FLAGS; \
298 if (failed) \
299 break; \
300 } \
301 if (failed) \
302 break; \
303 } \
304 if (!failed) \
305 printk("passed\n"); \
306 }
307
308 #define VAL_BYTE_UNARY(name) \
309 printk("Validating %s ... ", #name); \
310 VAL_START_UNARY(u8,0xFF,0x1) \
311 VAL_TEST_UNARY(name) \
312 VAL_FAIL_BYTE_UNARY(name) \
313 VAL_END_UNARY()
314
315 #define VAL_WORD_UNARY(name) \
316 printk("Validating %s ... ", #name); \
317 VAL_START_UNARY(u16,0xFF00,0x100) \
318 VAL_TEST_UNARY(name) \
319 VAL_FAIL_WORD_UNARY(name) \
320 VAL_END_UNARY()
321
322 #define VAL_WORD_BYTE_UNARY(name) \
323 printk("Validating %s ... ", #name); \
324 VAL_START_UNARY(u16,0xFF,0x1) \
325 VAL_TEST_UNARY(name) \
326 VAL_FAIL_WORD_UNARY(name) \
327 VAL_END_UNARY()
328
329 #define VAL_LONG_UNARY(name) \
330 printk("Validating %s ... ", #name); \
331 VAL_START_UNARY(u32,0xFF000000,0x1000000) \
332 VAL_TEST_UNARY(name) \
333 VAL_FAIL_LONG_UNARY(name) \
334 VAL_END_UNARY()
335
336 #define VAL_BYTE_MUL(name) \
337 printk("Validating %s ... ", #name); \
338 { \
339 u8 d,s; \
340 u16 r,r_asm; \
341 u32 flags,inflags; \
342 int f,failed = false; \
343 char buf1[80],buf2[80]; \
344 for (d = 0; d < 0xFF; d += 1) { \
345 for (s = 0; s < 0xFF; s += 1) { \
346 M.x86.R_EFLG = inflags = flags = def_flags; \
347 for (f = 0; f < 2; f++) { \
348 name##_asm(&flags,&r_asm,d,s); \
349 M.x86.R_AL = d; \
350 name(s); \
351 r = M.x86.R_AX; \
352 if (r != r_asm || M.x86.R_EFLG != flags) \
353 failed = true; \
354 if (failed || trace) { \
355 if (failed) \
356 printk("fail\n"); \
357 printk("0x%04X = %-15s(0x%02X,0x%02X), flags = %s -> %s\n", \
358 r, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
359 printk("0x%04X = %-15s(0x%02X,0x%02X), flags = %s -> %s\n", \
360 r_asm, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags)); \
361 } \
362 M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF); \
363 if (failed) \
364 break; \
365 } \
366 if (failed) \
367 break; \
368 } \
369 if (failed) \
370 break; \
371 } \
372 if (!failed) \
373 printk("passed\n"); \
374 }
375
376 #define VAL_WORD_MUL(name) \
377 printk("Validating %s ... ", #name); \
378 { \
379 u16 d,s; \
380 u16 r_lo,r_asm_lo; \
381 u16 r_hi,r_asm_hi; \
382 u32 flags,inflags; \
383 int f,failed = false; \
384 char buf1[80],buf2[80]; \
385 for (d = 0; d < 0xFF00; d += 0x100) { \
386 for (s = 0; s < 0xFF00; s += 0x100) { \
387 M.x86.R_EFLG = inflags = flags = def_flags; \
388 for (f = 0; f < 2; f++) { \
389 name##_asm(&flags,&r_asm_lo,&r_asm_hi,d,s); \
390 M.x86.R_AX = d; \
391 name(s); \
392 r_lo = M.x86.R_AX; \
393 r_hi = M.x86.R_DX; \
394 if (r_lo != r_asm_lo || r_hi != r_asm_hi || M.x86.R_EFLG != flags)\
395 failed = true; \
396 if (failed || trace) { \
397 if (failed) \
398 printk("fail\n"); \
399 printk("0x%04X:0x%04X = %-15s(0x%04X,0x%04X), flags = %s -> %s\n", \
400 r_hi,r_lo, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
401 printk("0x%04X:0x%04X = %-15s(0x%04X,0x%04X), flags = %s -> %s\n", \
402 r_asm_hi,r_asm_lo, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags)); \
403 } \
404 M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF); \
405 if (failed) \
406 break; \
407 } \
408 if (failed) \
409 break; \
410 } \
411 if (failed) \
412 break; \
413 } \
414 if (!failed) \
415 printk("passed\n"); \
416 }
417
418 #define VAL_LONG_MUL(name) \
419 printk("Validating %s ... ", #name); \
420 { \
421 u32 d,s; \
422 u32 r_lo,r_asm_lo; \
423 u32 r_hi,r_asm_hi; \
424 u32 flags,inflags; \
425 int f,failed = false; \
426 char buf1[80],buf2[80]; \
427 for (d = 0; d < 0xFF000000; d += 0x1000000) { \
428 for (s = 0; s < 0xFF000000; s += 0x1000000) { \
429 M.x86.R_EFLG = inflags = flags = def_flags; \
430 for (f = 0; f < 2; f++) { \
431 name##_asm(&flags,&r_asm_lo,&r_asm_hi,d,s); \
432 M.x86.R_EAX = d; \
433 name(s); \
434 r_lo = M.x86.R_EAX; \
435 r_hi = M.x86.R_EDX; \
436 if (r_lo != r_asm_lo || r_hi != r_asm_hi || M.x86.R_EFLG != flags)\
437 failed = true; \
438 if (failed || trace) { \
439 if (failed) \
440 printk("fail\n"); \
441 printk("0x%08X:0x%08X = %-15s(0x%08X,0x%08X), flags = %s -> %s\n", \
442 r_hi,r_lo, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
443 printk("0x%08X:0x%08X = %-15s(0x%08X,0x%08X), flags = %s -> %s\n", \
444 r_asm_hi,r_asm_lo, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags)); \
445 } \
446 M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF); \
447 if (failed) \
448 break; \
449 } \
450 if (failed) \
451 break; \
452 } \
453 if (failed) \
454 break; \
455 } \
456 if (!failed) \
457 printk("passed\n"); \
458 }
459
460 #define VAL_BYTE_DIV(name) \
461 printk("Validating %s ... ", #name); \
462 { \
463 u16 d,s; \
464 u8 r_quot,r_rem,r_asm_quot,r_asm_rem; \
465 u32 flags,inflags; \
466 int f,failed = false; \
467 char buf1[80],buf2[80]; \
468 for (d = 0; d < 0xFF00; d += 0x100) { \
469 for (s = 1; s < 0xFF; s += 1) { \
470 M.x86.R_EFLG = inflags = flags = def_flags; \
471 for (f = 0; f < 2; f++) { \
472 M.x86.intr = 0; \
473 M.x86.R_AX = d; \
474 name(s); \
475 r_quot = M.x86.R_AL; \
476 r_rem = M.x86.R_AH; \
477 if (M.x86.intr & INTR_SYNCH) \
478 continue; \
479 name##_asm(&flags,&r_asm_quot,&r_asm_rem,d,s); \
480 if (r_quot != r_asm_quot || r_rem != r_asm_rem || M.x86.R_EFLG != flags) \
481 failed = true; \
482 if (failed || trace) { \
483 if (failed) \
484 printk("fail\n"); \
485 printk("0x%02X:0x%02X = %-15s(0x%04X,0x%02X), flags = %s -> %s\n", \
486 r_quot, r_rem, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
487 printk("0x%02X:0x%02X = %-15s(0x%04X,0x%02X), flags = %s -> %s\n", \
488 r_asm_quot, r_asm_rem, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags)); \
489 } \
490 M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF); \
491 if (failed) \
492 break; \
493 } \
494 if (failed) \
495 break; \
496 } \
497 if (failed) \
498 break; \
499 } \
500 if (!failed) \
501 printk("passed\n"); \
502 }
503
504 #define VAL_WORD_DIV(name) \
505 printk("Validating %s ... ", #name); \
506 { \
507 u32 d,s; \
508 u16 r_quot,r_rem,r_asm_quot,r_asm_rem; \
509 u32 flags,inflags; \
510 int f,failed = false; \
511 char buf1[80],buf2[80]; \
512 for (d = 0; d < 0xFF000000; d += 0x1000000) { \
513 for (s = 0x100; s < 0xFF00; s += 0x100) { \
514 M.x86.R_EFLG = inflags = flags = def_flags; \
515 for (f = 0; f < 2; f++) { \
516 M.x86.intr = 0; \
517 M.x86.R_AX = d & 0xFFFF; \
518 M.x86.R_DX = d >> 16; \
519 name(s); \
520 r_quot = M.x86.R_AX; \
521 r_rem = M.x86.R_DX; \
522 if (M.x86.intr & INTR_SYNCH) \
523 continue; \
524 name##_asm(&flags,&r_asm_quot,&r_asm_rem,d & 0xFFFF,d >> 16,s);\
525 if (r_quot != r_asm_quot || r_rem != r_asm_rem || M.x86.R_EFLG != flags) \
526 failed = true; \
527 if (failed || trace) { \
528 if (failed) \
529 printk("fail\n"); \
530 printk("0x%04X:0x%04X = %-15s(0x%08X,0x%04X), flags = %s -> %s\n", \
531 r_quot, r_rem, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
532 printk("0x%04X:0x%04X = %-15s(0x%08X,0x%04X), flags = %s -> %s\n", \
533 r_asm_quot, r_asm_rem, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags)); \
534 } \
535 M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF); \
536 if (failed) \
537 break; \
538 } \
539 if (failed) \
540 break; \
541 } \
542 if (failed) \
543 break; \
544 } \
545 if (!failed) \
546 printk("passed\n"); \
547 }
548
549 #define VAL_LONG_DIV(name) \
550 printk("Validating %s ... ", #name); \
551 { \
552 u32 d,s; \
553 u32 r_quot,r_rem,r_asm_quot,r_asm_rem; \
554 u32 flags,inflags; \
555 int f,failed = false; \
556 char buf1[80],buf2[80]; \
557 for (d = 0; d < 0xFF000000; d += 0x1000000) { \
558 for (s = 0x100; s < 0xFF00; s += 0x100) { \
559 M.x86.R_EFLG = inflags = flags = def_flags; \
560 for (f = 0; f < 2; f++) { \
561 M.x86.intr = 0; \
562 M.x86.R_EAX = d; \
563 M.x86.R_EDX = 0; \
564 name(s); \
565 r_quot = M.x86.R_EAX; \
566 r_rem = M.x86.R_EDX; \
567 if (M.x86.intr & INTR_SYNCH) \
568 continue; \
569 name##_asm(&flags,&r_asm_quot,&r_asm_rem,d,0,s); \
570 if (r_quot != r_asm_quot || r_rem != r_asm_rem || M.x86.R_EFLG != flags) \
571 failed = true; \
572 if (failed || trace) { \
573 if (failed) \
574 printk("fail\n"); \
575 printk("0x%08X:0x%08X = %-15s(0x%08X:0x%08X,0x%08X), flags = %s -> %s\n", \
576 r_quot, r_rem, #name, 0, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
577 printk("0x%08X:0x%08X = %-15s(0x%08X:0x%08X,0x%08X), flags = %s -> %s\n", \
578 r_asm_quot, r_asm_rem, #name"_asm", 0, d, s, print_flags(buf1,inflags), print_flags(buf2,flags)); \
579 } \
580 M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF); \
581 if (failed) \
582 break; \
583 } \
584 if (failed) \
585 break; \
586 } \
587 if (failed) \
588 break; \
589 } \
590 if (!failed) \
591 printk("passed\n"); \
592 }
593
594 void
595 printk(const char *fmt, ...)
596 {
597 va_list argptr;
598
599 va_start(argptr, fmt);
600 vfprintf(stdout, fmt, argptr);
601 fflush(stdout);
602 va_end(argptr);
603 }
604
605 char *
606 print_flags(char *buf, ulong flags)
607 {
608 char *separator = "";
609
610 buf[0] = 0;
611 if (flags & F_CF) {
612 strcat(buf, separator);
613 strcat(buf, "CF");
614 separator = ",";
615 }
616 if (flags & F_PF) {
617 strcat(buf, separator);
618 strcat(buf, "PF");
619 separator = ",";
620 }
621 if (flags & F_AF) {
622 strcat(buf, separator);
623 strcat(buf, "AF");
624 separator = ",";
625 }
626 if (flags & F_ZF) {
627 strcat(buf, separator);
628 strcat(buf, "ZF");
629 separator = ",";
630 }
631 if (flags & F_SF) {
632 strcat(buf, separator);
633 strcat(buf, "SF");
634 separator = ",";
635 }
636 if (flags & F_OF) {
637 strcat(buf, separator);
638 strcat(buf, "OF");
639 separator = ",";
640 }
641 if (separator[0] == 0)
642 strcpy(buf, "None");
643 return buf;
644 }
645
646 int
647 main(int argc)
648 {
649 ulong def_flags;
650 int trace = false;
651
652 if (argc > 1)
653 trace = true;
654 memset(&M, 0, sizeof(M));
655 def_flags = get_flags_asm() & ~ALL_FLAGS;
656
657 VAL_WORD_UNARY(aaa_word);
658 VAL_WORD_UNARY(aas_word);
659
660 VAL_WORD_UNARY(aad_word);
661 VAL_WORD_UNARY(aam_word);
662
663 VAL_BYTE_BYTE_BINARY(adc_byte);
664 VAL_WORD_WORD_BINARY(adc_word);
665 VAL_LONG_LONG_BINARY(adc_long);
666
667 VAL_BYTE_BYTE_BINARY(add_byte);
668 VAL_WORD_WORD_BINARY(add_word);
669 VAL_LONG_LONG_BINARY(add_long);
670
671 VAL_BYTE_BYTE_BINARY(and_byte);
672 VAL_WORD_WORD_BINARY(and_word);
673 VAL_LONG_LONG_BINARY(and_long);
674
675 VAL_BYTE_BYTE_BINARY(cmp_byte);
676 VAL_WORD_WORD_BINARY(cmp_word);
677 VAL_LONG_LONG_BINARY(cmp_long);
678
679 VAL_BYTE_UNARY(daa_byte);
680 VAL_BYTE_UNARY(das_byte); /* Fails for 0x9A (out of range anyway) */
681
682 VAL_BYTE_UNARY(dec_byte);
683 VAL_WORD_UNARY(dec_word);
684 VAL_LONG_UNARY(dec_long);
685
686 VAL_BYTE_UNARY(inc_byte);
687 VAL_WORD_UNARY(inc_word);
688 VAL_LONG_UNARY(inc_long);
689
690 VAL_BYTE_BYTE_BINARY(or_byte);
691 VAL_WORD_WORD_BINARY(or_word);
692 VAL_LONG_LONG_BINARY(or_long);
693
694 VAL_BYTE_UNARY(neg_byte);
695 VAL_WORD_UNARY(neg_word);
696 VAL_LONG_UNARY(neg_long);
697
698 VAL_BYTE_UNARY(not_byte);
699 VAL_WORD_UNARY(not_word);
700 VAL_LONG_UNARY(not_long);
701
702 VAL_BYTE_ROTATE(rcl_byte);
703 VAL_WORD_ROTATE(rcl_word);
704 VAL_LONG_ROTATE(rcl_long);
705
706 VAL_BYTE_ROTATE(rcr_byte);
707 VAL_WORD_ROTATE(rcr_word);
708 VAL_LONG_ROTATE(rcr_long);
709
710 VAL_BYTE_ROTATE(rol_byte);
711 VAL_WORD_ROTATE(rol_word);
712 VAL_LONG_ROTATE(rol_long);
713
714 VAL_BYTE_ROTATE(ror_byte);
715 VAL_WORD_ROTATE(ror_word);
716 VAL_LONG_ROTATE(ror_long);
717
718 VAL_BYTE_ROTATE(shl_byte);
719 VAL_WORD_ROTATE(shl_word);
720 VAL_LONG_ROTATE(shl_long);
721
722 VAL_BYTE_ROTATE(shr_byte);
723 VAL_WORD_ROTATE(shr_word);
724 VAL_LONG_ROTATE(shr_long);
725
726 VAL_BYTE_ROTATE(sar_byte);
727 VAL_WORD_ROTATE(sar_word);
728 VAL_LONG_ROTATE(sar_long);
729
730 VAL_WORD_ROTATE_DBL(shld_word);
731 VAL_LONG_ROTATE_DBL(shld_long);
732
733 VAL_WORD_ROTATE_DBL(shrd_word);
734 VAL_LONG_ROTATE_DBL(shrd_long);
735
736 VAL_BYTE_BYTE_BINARY(sbb_byte);
737 VAL_WORD_WORD_BINARY(sbb_word);
738 VAL_LONG_LONG_BINARY(sbb_long);
739
740 VAL_BYTE_BYTE_BINARY(sub_byte);
741 VAL_WORD_WORD_BINARY(sub_word);
742 VAL_LONG_LONG_BINARY(sub_long);
743
744 VAL_BYTE_BYTE_BINARY(xor_byte);
745 VAL_WORD_WORD_BINARY(xor_word);
746 VAL_LONG_LONG_BINARY(xor_long);
747
748 VAL_VOID_BYTE_BINARY(test_byte);
749 VAL_VOID_WORD_BINARY(test_word);
750 VAL_VOID_LONG_BINARY(test_long);
751
752 VAL_BYTE_MUL(imul_byte);
753 VAL_WORD_MUL(imul_word);
754 VAL_LONG_MUL(imul_long);
755
756 VAL_BYTE_MUL(mul_byte);
757 VAL_WORD_MUL(mul_word);
758 VAL_LONG_MUL(mul_long);
759
760 VAL_BYTE_DIV(idiv_byte);
761 VAL_WORD_DIV(idiv_word);
762 VAL_LONG_DIV(idiv_long);
763
764 VAL_BYTE_DIV(div_byte);
765 VAL_WORD_DIV(div_word);
766 VAL_LONG_DIV(div_long);
767
768 return 0;
769 }
Clone of Haiku svn repository