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