WebSVN – Kolibri OS – Diff – /programs/develop/cmm/disasm.cpp

Rev 6446		Rev 7626
1	#include "tok.h"	1	#include "tok.h"
2		2
3	#include "table.h"	3	#include "table.h"
4		4
5	#include	5	#include
6		6
7	#define _DISASM_	7	#define _DISASM_
8		8
9		9
10		10
11	/* Percent tokens in strings:	11	/* Percent tokens in strings:
12		12
13	First char after '%':	13	First char after '%':
14		14
15	A - direct address	15	A - direct address
16		16
17	C - reg of r/m picks control register	17	C - reg of r/m picks control register
18		18
19	D - reg of r/m picks debug register	19	D - reg of r/m picks debug register
20		20
21	E - r/m picks operand	21	E - r/m picks operand
22		22
23	F - second operand for mmx instruction reg/mem	23	F - second operand for mmx instruction reg/mem
24		24
25	G - reg of r/m picks general register	25	G - reg of r/m picks general register
26		26
27	I - immediate data	27	I - immediate data
28		28
29	J - relative IP offset	29	J - relative IP offset
30		30
31	+ K - call/jmp distance	31	+ K - call/jmp distance
32		32
33	L - first operand for mmx instruction	33	L - first operand for mmx instruction
34		34
35	M - r/m picks memory	35	M - r/m picks memory
36		36
37	O - no r/m, offset only	37	O - no r/m, offset only
38		38
39	R - mod of r/m picks register only	39	R - mod of r/m picks register only
40		40
41	S - reg of r/m picks segment register	41	S - reg of r/m picks segment register
42		42
43	T - reg of r/m picks test register	43	T - reg of r/m picks test register
44		44
45	X - DS:ESI	45	X - DS:ESI
46		46
47	Y - ES:EDI	47	Y - ES:EDI
48		48
49	2 - prefix of two-byte opcode	49	2 - prefix of two-byte opcode
50		50
51	+ e - put in 'e' if use32 (second char is part of reg name)	51	+ e - put in 'e' if use32 (second char is part of reg name)
52		52
53	+ put in 'w' for use16 or 'd' for use32 (second char is 'w')	53	+ put in 'w' for use16 or 'd' for use32 (second char is 'w')
54		54
55	+ j - put in 'e' in jcxz if prefix==0x66	55	+ j - put in 'e' in jcxz if prefix==0x66
56		56
57	f - floating point (second char is esc value)	57	f - floating point (second char is esc value)
58		58
59	g - do r/m group 'n', n==0..7	59	g - do r/m group 'n', n==0..7
60		60
61	p - prefix	61	p - prefix
62		62
63	s - size override (second char is a,o)	63	s - size override (second char is a,o)
64		64
65	+ d - put d if double arg, nothing otherwise (pushfd, popfd &c)	65	+ d - put d if double arg, nothing otherwise (pushfd, popfd &c)
66		66
67	+ w - put w if word, d if double arg, nothing otherwise (lodsw/lodsd)	67	+ w - put w if word, d if double arg, nothing otherwise (lodsw/lodsd)
68		68
69	+ P - simple prefix	69	+ P - simple prefix
70		70
71		71
72		72
73	Second char after '%':	73	Second char after '%':
74		74
75	a - two words in memory (BOUND)	75	a - two words in memory (BOUND)
76		76
77	b - byte	77	b - byte
78		78
79	c - byte or word	79	c - byte or word
80		80
81	d - dword	81	d - dword
82		82
83	+ f - far call/jmp	83	+ f - far call/jmp
84		84
85	+ n - near call/jmp	85	+ n - near call/jmp
86		86
87	p - 32 or 48 bit pointer	87	p - 32 or 48 bit pointer
88		88
89	+ q - byte/word thingy	89	+ q - byte/word thingy
90		90
91	s - six byte pseudo-descriptor	91	s - six byte pseudo-descriptor
92		92
93	v - word or dword	93	v - word or dword
94		94
95	w - word	95	w - word
96		96
97	+ x - sign extended byte	97	+ x - sign extended byte
98		98
99	y - qword	99	y - qword
100		100
101	F - use floating regs in mod/rm	101	F - use floating regs in mod/rm
102		102
103	M - use MMX regs	103	M - use MMX regs
104		104
105	1-8 - group number, esc value, etc	105	1-8 - group number, esc value, etc
106		106
107	m - no size memory operand	107	m - no size memory operand
108		108
109	*/	109	*/
110		110
111		111
112		112
113	/* watch out for aad && aam with odd operands */	113	/* watch out for aad && aam with odd operands */
114		114
115	char *opmap1[256]={	115	char *opmap1[256]={
116		116
117	/* 0 */	117	/* 0 */
118		118
119	"add %Eb,%Rb", "add %Ev,%Rv", "add %Rb,%Eb", "add %Rv,%Ev",	119	"add %Eb,%Rb", "add %Ev,%Rv", "add %Rb,%Eb", "add %Rv,%Ev",
120		120
121	"add al,%Ib", "add %eax,%Iv", "push es", "pop es",	121	"add al,%Ib", "add %eax,%Iv", "push es", "pop es",
122		122
123	"or %Eb,%Rb", "or %Ev,%Rv", "or %Rb,%Eb", "or %Rv,%Ev",	123	"or %Eb,%Rb", "or %Ev,%Rv", "or %Rb,%Eb", "or %Rv,%Ev",
124		124
125	"or al,%Ib", "or %eax,%Iv", "push cs", "%2 ",	125	"or al,%Ib", "or %eax,%Iv", "push cs", "%2 ",
126		126
127	/* 1 */	127	/* 1 */
128		128
129	"adc %Eb,%Rb", "adc %Ev,%Rv", "adc %Rb,%Eb", "adc %Rv,%Ev",	129	"adc %Eb,%Rb", "adc %Ev,%Rv", "adc %Rb,%Eb", "adc %Rv,%Ev",
130		130
131	"adc al,%Ib", "adc %eax,%Iv", "push ss", "pop ss",	131	"adc al,%Ib", "adc %eax,%Iv", "push ss", "pop ss",
132		132
133	"sbb %Eb,%Rb", "sbb %Ev,%Rv", "sbb %Rb,%Eb", "sbb %Rv,%Ev",	133	"sbb %Eb,%Rb", "sbb %Ev,%Rv", "sbb %Rb,%Eb", "sbb %Rv,%Ev",
134		134
135	"sbb al,%Ib", "sbb %eax,%Iv", "push ds", "pop ds",	135	"sbb al,%Ib", "sbb %eax,%Iv", "push ds", "pop ds",
136		136
137	/* 2 */	137	/* 2 */
138		138
139	"and %Eb,%Rb", "and %Ev,%Rv", "and %Rb,%Eb", "and %Rv,%Ev",	139	"and %Eb,%Rb", "and %Ev,%Rv", "and %Rb,%Eb", "and %Rv,%Ev",
140		140
141	"and al,%Ib", "and %eax,%Iv", "%pe", "daa",	141	"and al,%Ib", "and %eax,%Iv", "%pe", "daa",
142		142
143	"sub %Eb,%Rb", "sub %Ev,%Rv", "sub %Rb,%Eb", "sub %Rv,%Ev",	143	"sub %Eb,%Rb", "sub %Ev,%Rv", "sub %Rb,%Eb", "sub %Rv,%Ev",
144		144
145	"sub al,%Ib", "sub %eax,%Iv", "%pc", "das",	145	"sub al,%Ib", "sub %eax,%Iv", "%pc", "das",
146		146
147	/* 3 */	147	/* 3 */
148		148
149	"xor %Eb,%Rb", "xor %Ev,%Rv", "xor %Rb,%Eb", "xor %Rv,%Ev",	149	"xor %Eb,%Rb", "xor %Ev,%Rv", "xor %Rb,%Eb", "xor %Rv,%Ev",
150		150
151	"xor al,%Ib", "xor %eax,%Iv", "%ps", "aaa",	151	"xor al,%Ib", "xor %eax,%Iv", "%ps", "aaa",
152		152
153	"cmp %Eb,%Rb", "cmp %Ev,%Rv", "cmp %Rb,%Eb", "cmp %Rv,%Ev",	153	"cmp %Eb,%Rb", "cmp %Ev,%Rv", "cmp %Rb,%Eb", "cmp %Rv,%Ev",
154		154
155	"cmp al,%Ib", "cmp %eax,%Iv", "%pd", "aas",	155	"cmp al,%Ib", "cmp %eax,%Iv", "%pd", "aas",
156		156
157	/* 4 */	157	/* 4 */
158		158
159	"inc %eax", "inc %ecx", "inc %edx", "inc %ebx",	159	"inc %eax", "inc %ecx", "inc %edx", "inc %ebx",
160		160
161	"inc %esp", "inc %ebp", "inc %esi", "inc %edi",	161	"inc %esp", "inc %ebp", "inc %esi", "inc %edi",
162		162
163	"dec %eax", "dec %ecx", "dec %edx", "dec %ebx",	163	"dec %eax", "dec %ecx", "dec %edx", "dec %ebx",
164		164
165	"dec %esp", "dec %ebp", "dec %esi", "dec %edi",	165	"dec %esp", "dec %ebp", "dec %esi", "dec %edi",
166		166
167	/* 5 */	167	/* 5 */
168		168
169	"push %eax", "push %ecx", "push %edx", "push %ebx",	169	"push %eax", "push %ecx", "push %edx", "push %ebx",
170		170
171	"push %esp", "push %ebp", "push %esi", "push %edi",	171	"push %esp", "push %ebp", "push %esi", "push %edi",
172		172
173	"pop %eax", "pop %ecx", "pop %edx", "pop %ebx",	173	"pop %eax", "pop %ecx", "pop %edx", "pop %ebx",
174		174
175	"pop %esp", "pop %ebp", "pop %esi", "pop %edi",	175	"pop %esp", "pop %ebp", "pop %esi", "pop %edi",
176		176
177	/* 6 */	177	/* 6 */
178		178
179	"pusha%d ", "popa%d ", "bound %Rv,%Ma", "arpl %Ew,%Rw",	179	"pusha%d ", "popa%d ", "bound %Rv,%Ma", "arpl %Ew,%Rw",
180		180
181	"%pf", "%pg", "%so", "%sa",	181	"%pf", "%pg", "%so", "%sa",
182		182
183	"push %Iv", "imul %Rv,%Ev,%Iv","push %Ix", "imul %Rv,%Ev,%Ib",	183	"push %Iv", "imul %Rv,%Ev,%Iv","push %Ix", "imul %Rv,%Ev,%Ib",
184		184
185	"insb", "ins%ew", "outsb", "outs%ew",	185	"insb", "ins%ew", "outsb", "outs%ew",
186		186
187	/* 7 */	187	/* 7 */
188		188
189	"jo %Jb", "jno %Jb", "jc %Jb", "jnc %Jb",	189	"jo %Jb", "jno %Jb", "jc %Jb", "jnc %Jb",
190		190
191	"je %Jb", "jne %Jb", "jbe %Jb", "ja %Jb",	191	"je %Jb", "jne %Jb", "jbe %Jb", "ja %Jb",
192		192
193	"js %Jb", "jns %Jb", "jpe %Jb", "jpo %Jb",	193	"js %Jb", "jns %Jb", "jpe %Jb", "jpo %Jb",
194		194
195	"jl %Jb", "jge %Jb", "jle %Jb", "jg %Jb",	195	"jl %Jb", "jge %Jb", "jle %Jb", "jg %Jb",
196		196
197	/* 8 */	197	/* 8 */
198		198
199	/* "%g0 %Eb,%Ib", "%g0 %Ev,%Iv", "%g0 %Ev,%Ib", "%g0 %Ev,%Ib", */	199	/* "%g0 %Eb,%Ib", "%g0 %Ev,%Iv", "%g0 %Ev,%Ib", "%g0 %Ev,%Ib", */
200		200
201	"%g0 %Eb,%Ib", "%g0 %Ev,%Iv", "%g0 %Ev,%Ix", "%g0 %Ev,%Ix",	201	"%g0 %Eb,%Ib", "%g0 %Ev,%Iv", "%g0 %Ev,%Ix", "%g0 %Ev,%Ix",
202		202
203	"test %Eb,%Rb", "test %Ev,%Rv", "xchg %Eb,%Rb", "xchg %Ev,%Rv",	203	"test %Eb,%Rb", "test %Ev,%Rv", "xchg %Eb,%Rb", "xchg %Ev,%Rv",
204		204
205	"mov %Eb,%Rb", "mov %Ev,%Rv", "mov %Rb,%Eb", "mov %Rv,%Ev",	205	"mov %Eb,%Rb", "mov %Ev,%Rv", "mov %Rb,%Eb", "mov %Rv,%Ev",
206		206
207	"mov %Ew,%Sw", "lea %Rv,%M ", "mov %Sw,%Ew", "pop %Ev",	207	"mov %Ew,%Sw", "lea %Rv,%M ", "mov %Sw,%Ew", "pop %Ev",
208		208
209	/* 9 */	209	/* 9 */
210		210
211	"nop", "xchg %ecx,%eax", "xchg %edx,%eax", "xchg %ebx,%eax",	211	"nop", "xchg %ecx,%eax", "xchg %edx,%eax", "xchg %ebx,%eax",
212		212
213	"xchg %esp,%eax", "xchg %ebp,%eax", "xchg %esi,%eax", "xchg %edi,%eax",	213	"xchg %esp,%eax", "xchg %ebp,%eax", "xchg %esi,%eax", "xchg %edi,%eax",
214		214
215	"cbw", "cwd", "call %Ap", "fwait",	215	"cbw", "cwd", "call %Ap", "fwait",
216		216
217	"pushf%d ", "popf%d ", "sahf", "lahf",	217	"pushf%d ", "popf%d ", "sahf", "lahf",
218		218
219	/* a */	219	/* a */
220		220
221	"mov al,%Oc", "mov %eax,%Ov", "mov %Oc,al", "mov %Ov,%eax",	221	"mov al,%Oc", "mov %eax,%Ov", "mov %Oc,al", "mov %Ov,%eax",
222		222
223	"%P movsb", "%P movs%w", "%P cmpsb", "%P cmps%w ",	223	"%P movsb", "%P movs%w", "%P cmpsb", "%P cmps%w ",
224		224
225	"test al,%Ib", "test %eax,%Iv", "%P stosb", "%P stos%w ",	225	"test al,%Ib", "test %eax,%Iv", "%P stosb", "%P stos%w ",
226		226
227	"%P lodsb", "%P lods%w ", "%P scasb", "%P scas%w ",	227	"%P lodsb", "%P lods%w ", "%P scasb", "%P scas%w ",
228		228
229	/* b */	229	/* b */
230		230
231	"mov al,%Ib", "mov cl,%Ib", "mov dl,%Ib", "mov bl,%Ib",	231	"mov al,%Ib", "mov cl,%Ib", "mov dl,%Ib", "mov bl,%Ib",
232		232
233	"mov ah,%Ib", "mov ch,%Ib", "mov dh,%Ib", "mov bh,%Ib",	233	"mov ah,%Ib", "mov ch,%Ib", "mov dh,%Ib", "mov bh,%Ib",
234		234
235	"mov %eax,%Iv", "mov %ecx,%Iv", "mov %edx,%Iv", "mov %ebx,%Iv",	235	"mov %eax,%Iv", "mov %ecx,%Iv", "mov %edx,%Iv", "mov %ebx,%Iv",
236		236
237	"mov %esp,%Iv", "mov %ebp,%Iv", "mov %esi,%Iv", "mov %edi,%Iv",	237	"mov %esp,%Iv", "mov %ebp,%Iv", "mov %esi,%Iv", "mov %edi,%Iv",
238		238
239	/* c */	239	/* c */
240		240
241	"%g1 %Eb,%Ib", "%g1 %Ev,%Ib", "ret %Iw", "ret",	241	"%g1 %Eb,%Ib", "%g1 %Ev,%Ib", "ret %Iw", "ret",
242		242
243	"les %Rv,%Mp", "lds %Rv,%Mp", "mov %Eb,%Ib", "mov %Ev,%Iv",	243	"les %Rv,%Mp", "lds %Rv,%Mp", "mov %Eb,%Ib", "mov %Ev,%Iv",
244		244
245	"enter %Iw,%Ib", "leave", "retf %Iw", "retf",	245	"enter %Iw,%Ib", "leave", "retf %Iw", "retf",
246		246
247	"int 03", "int %Ib", "into", "iret",	247	"int 03", "int %Ib", "into", "iret",
248		248
249	/* d */	249	/* d */
250		250
251	"%g1 %Eb,1", "%g1 %Ev,1", "%g1 %Eb,cl", "%g1 %Ev,cl",	251	"%g1 %Eb,1", "%g1 %Ev,1", "%g1 %Eb,cl", "%g1 %Ev,cl",
252		252
253	"aam ; %Ib", "aad ; %Ib", "setalc", "xlat",	253	"aam ; %Ib", "aad ; %Ib", "setalc", "xlat",
254		254
255	/*#if 0	255	/*#if 0
256		256
257	"esc 0,%Ib", "esc 1,%Ib", "esc 2,%Ib", "esc 3,%Ib",	257	"esc 0,%Ib", "esc 1,%Ib", "esc 2,%Ib", "esc 3,%Ib",
258		258
259	"esc 4,%Ib", "esc 5,%Ib", "esc 6,%Ib", "esc 7,%Ib",	259	"esc 4,%Ib", "esc 5,%Ib", "esc 6,%Ib", "esc 7,%Ib",
260		260
261	#else */	261	#else */
262		262
263	"%f0", "%f1", "%f2", "%f3",	263	"%f0", "%f1", "%f2", "%f3",
264		264
265	"%f4", "%f5", "%f6", "%f7",	265	"%f4", "%f5", "%f6", "%f7",
266		266
267	//#endif	267	//#endif
268		268
269	/* e */	269	/* e */
270		270
271	"loopne %Jb", "loope %Jb", "loop %Jb", "j%j cxz %Jb",	271	"loopne %Jb", "loope %Jb", "loop %Jb", "j%j cxz %Jb",
272		272
273	"in al,%Ib", "in %eax,%Ib", "out %Ib,al", "out %Ib,%eax",	273	"in al,%Ib", "in %eax,%Ib", "out %Ib,al", "out %Ib,%eax",
274		274
275	"call %Jv", "jmp %Jv", "jmp %Ap", "jmp %Ks%Jb",	275	"call %Jv", "jmp %Jv", "jmp %Ap", "jmp %Ks%Jb",
276		276
277	"in al,dx", "in %eax,dx", "out dx,al", "out dx,%eax",	277	"in al,dx", "in %eax,dx", "out dx,al", "out dx,%eax",
278		278
279	/* f */	279	/* f */
280		280
281	"lock %p ", 0, "repne %p ", "repe %p ",	281	"lock %p ", 0, "repne %p ", "repe %p ",
282		282
283	"hlt", "cmc", "%g2", "%g2",	283	"hlt", "cmc", "%g2", "%g2",
284		284
285	"clc", "stc", "cli", "sti",	285	"clc", "stc", "cli", "sti",
286		286
287	"cld", "std", "%g3", "%g4"	287	"cld", "std", "%g3", "%g4"
288		288
289	};	289	};
290		290
291		291
292		292
293	char *second[] = {	293	char *second[] = {
294		294
295	/* 0 */	295	/* 0 */
296		296
297	"%g5", "%g6", "lar %Rv,%Ew", "lsl %Rv,%Ew",	297	"%g5", "%g6", "lar %Rv,%Ew", "lsl %Rv,%Ew",
298		298
299	0, "loadall", "clts", "loadall",	299	0, "loadall", "clts", "loadall",
300		300
301	"invd", "wbinvd", 0, "ud2",	301	"invd", "wbinvd", 0, "ud2",
302		302
303	0, 0, 0, 0,	303	0, 0, 0, 0,
304		304
305	/* 1 */	305	/* 1 */
306		306
307	"movups %RX,%EX", "movups %Md,%RX", "%x0", "movlps %Md,%RX",	307	"movups %RX,%EX", "movups %Md,%RX", "%x0", "movlps %Md,%RX",
308		308
309	"unpcklps %RX,%EX", "unpckhps %RX,%EX","%x1", "movhps %Md,%RX",	309	"unpcklps %RX,%EX", "unpckhps %RX,%EX","%x1", "movhps %Md,%RX",
310		310
311	"%g7", 0, 0, 0,	311	"%g7", 0, 0, 0,
312		312
313	0, 0, 0, 0,	313	0, 0, 0, 0,
314		314
315	/* 2 */	315	/* 2 */
316		316
317	"mov %Ed,%Cd", "mov %Ed,%Dd", "mov %Cd,%Ed", "mov %Dd,%Ed",	317	"mov %Ed,%Cd", "mov %Ed,%Dd", "mov %Cd,%Ed", "mov %Dd,%Ed",
318		318
319	"mov %Ed,%Td", 0, "mov %Td,%Ed", 0,	319	"mov %Ed,%Td", 0, "mov %Td,%Ed", 0,
320		320
321	"movaps %RX,%EX", "movaps %Md,%RX", "cvtpi2ps %RX,%EM","movntps %Md,%RX",	321	"movaps %RX,%EX", "movaps %Md,%RX", "cvtpi2ps %RX,%EM","movntps %Md,%RX",
322		322
323	"cvttps2pi %RM,%EX","cvtps2pi %RM,%EX","ucomiss %RX,%EX", "comiss %RX,%EX",	323	"cvttps2pi %RM,%EX","cvtps2pi %RM,%EX","ucomiss %RX,%EX", "comiss %RX,%EX",
324		324
325	/* 3 */	325	/* 3 */
326		326
327	"wrmsr", "rdtsc", "rdmsr", "rdpmc", "sysenter", "sysexit", 0, 0,	327	"wrmsr", "rdtsc", "rdmsr", "rdpmc", "sysenter", "sysexit", 0, 0,
328		328
329	0, 0, 0, 0, 0, 0, 0, 0,	329	0, 0, 0, 0, 0, 0, 0, 0,
330		330
331	/* 4 */	331	/* 4 */
332		332
333	"cmovo %Rv,%Ev", "cmovno %Rv,%Ev", "cmovc %Rv,%Ev", "cmovnc %Rv,%Ev",	333	"cmovo %Rv,%Ev", "cmovno %Rv,%Ev", "cmovc %Rv,%Ev", "cmovnc %Rv,%Ev",
334		334
335	"cmovz %Rv,%Ev", "cmovnz %Rv,%Ev", "cmovbe %Rv,%Ev", "cmovnbe %Rv,%Ev",	335	"cmovz %Rv,%Ev", "cmovnz %Rv,%Ev", "cmovbe %Rv,%Ev", "cmovnbe %Rv,%Ev",
336		336
337	"cmovs %Rv,%Ev", "cmovns %Rv,%Ev", "cmovp %Rv,%Ev", "cmovnp %Rv,%Ev",	337	"cmovs %Rv,%Ev", "cmovns %Rv,%Ev", "cmovp %Rv,%Ev", "cmovnp %Rv,%Ev",
338		338
339	"cmovl %Rv,%Ev", "cmovge %Rv,%Ev", "cmovle %Rv,%Ev", "cmovg %Rv,%Ev",	339	"cmovl %Rv,%Ev", "cmovge %Rv,%Ev", "cmovle %Rv,%Ev", "cmovg %Rv,%Ev",
340		340
341	/* 5 */	341	/* 5 */
342		342
343	"movmskps %Rd,%GX", "sqrtps %RX,%EX", "rsqrtps %RX,%EX", "rcpps %RX,%EX",	343	"movmskps %Rd,%GX", "sqrtps %RX,%EX", "rsqrtps %RX,%EX", "rcpps %RX,%EX",
344		344
345	"andps %RX,%EX", "andnps %RX,%EX", "orps %RX,%EX", "xorps %RX,%EX",	345	"andps %RX,%EX", "andnps %RX,%EX", "orps %RX,%EX", "xorps %RX,%EX",
346		346
347	"addps %RX,%EX", "mulps %RX,%EX", "cvtps2pd %RX,%EX","cvtdq2ps %RX,%EX",	347	"addps %RX,%EX", "mulps %RX,%EX", "cvtps2pd %RX,%EX","cvtdq2ps %RX,%EX",
348		348
349	"subps %RX,%EX", "minps %RX,%EX", "divps %RX,%EX", "maxps %RX,%EX",	349	"subps %RX,%EX", "minps %RX,%EX", "divps %RX,%EX", "maxps %RX,%EX",
350		350
351	/* 6 */	351	/* 6 */
352		352
353	"punpcklbw %RM,%EM", "punpcklwd %RM,%EM", "punpckldq %RM,%EM", "packsswb %RM,%EM",	353	"punpcklbw %RM,%EM", "punpcklwd %RM,%EM", "punpckldq %RM,%EM", "packsswb %RM,%EM",
354		354
355	"pcmpgtb %RM,%EM", "pcmpgtw %RM,%EM", "pcmpgtd %RM,%EM", "packuswb %RM,%EM",	355	"pcmpgtb %RM,%EM", "pcmpgtw %RM,%EM", "pcmpgtd %RM,%EM", "packuswb %RM,%EM",
356		356
357	"punpckhbw %RM,%EM", "punpckhwd %RM,%EM", "punpckhdq %RM,%EM", "packssdw %RM,%EM",	357	"punpckhbw %RM,%EM", "punpckhwd %RM,%EM", "punpckhdq %RM,%EM", "packssdw %RM,%EM",
358		358
359	0, 0, "movd %RM,%Md", "movq %RM,%EM",	359	0, 0, "movd %RM,%Md", "movq %RM,%EM",
360		360
361	/* 7 */	361	/* 7 */
362		362
363	"pshufw %LM,%FM,%Ib","%g3w %EM,%Ib", "%g3d %EM,%Ib", "%g3q %EM,%Ib",	363	"pshufw %LM,%FM,%Ib","%g3w %EM,%Ib", "%g3d %EM,%Ib", "%g3q %EM,%Ib",
364		364
365	"pcmpeqb %RM,%EM", "pcmpeqw %RM,%EM", "pcmpeqd %RM,%EM", "emms",	365	"pcmpeqb %RM,%EM", "pcmpeqw %RM,%EM", "pcmpeqd %RM,%EM", "emms",
366		366
367	0, 0, 0, 0,	367	0, 0, 0, 0,
368		368
369	0, 0, "movd %Md,%RM", "movq %Md,%RM",	369	0, 0, "movd %Md,%RM", "movq %Md,%RM",
370		370
371	/* 8 */	371	/* 8 */
372		372
373	"jo %Jv", "jno %Jv", "jb %Jv", "jnb %Jv",	373	"jo %Jv", "jno %Jv", "jb %Jv", "jnb %Jv",
374		374
375	"jz %Jv", "jnz %Jv", "jbe %Jv", "ja %Jv",	375	"jz %Jv", "jnz %Jv", "jbe %Jv", "ja %Jv",
376		376
377	"js %Jv", "jns %Jv", "jp %Jv", "jnp %Jv",	377	"js %Jv", "jns %Jv", "jp %Jv", "jnp %Jv",
378		378
379	"jl %Jv", "jge %Jv", "jle %Jv", "jg %Jv",	379	"jl %Jv", "jge %Jv", "jle %Jv", "jg %Jv",
380		380
381	/* 9 */	381	/* 9 */
382		382
383	"seto %Eb", "setno %Eb", "setc %Eb", "setnc %Eb",	383	"seto %Eb", "setno %Eb", "setc %Eb", "setnc %Eb",
384		384
385	"setz %Eb", "setnz %Eb", "setbe %Eb", "setnbe %Eb",	385	"setz %Eb", "setnz %Eb", "setbe %Eb", "setnbe %Eb",
386		386
387	"sets %Eb", "setns %Eb", "setp %Eb", "setnp %Eb",	387	"sets %Eb", "setns %Eb", "setp %Eb", "setnp %Eb",
388		388
389	"setl %Eb", "setge %Eb", "setle %Eb", "setg %Eb",	389	"setl %Eb", "setge %Eb", "setle %Eb", "setg %Eb",
390		390
391	/* a */	391	/* a */
392		392
393	"push fs", "pop fs", "cpuid", "bt %Ev,%Rv",	393	"push fs", "pop fs", "cpuid", "bt %Ev,%Rv",
394		394
395	"shld %Ev,%Rv,%Ib", "shld %Ev,%Rv,cl", 0, 0,	395	"shld %Ev,%Rv,%Ib", "shld %Ev,%Rv,cl", 0, 0,
396		396
397	"push gs", "pop gs", "rsm", "bts %Ev,%Rv",	397	"push gs", "pop gs", "rsm", "bts %Ev,%Rv",
398		398
399	"shrd %Ev,%Rv,%Ib", "shrd %Ev,%Rv,cl", "%g8", "imul %Rv,%Ev",	399	"shrd %Ev,%Rv,%Ib", "shrd %Ev,%Rv,cl", "%g8", "imul %Rv,%Ev",
400		400
401	/* b */	401	/* b */
402		402
403	"cmpxchg %Eb,%Rb", "cmpxchg %Ev,%Rv", "lss %Rv,%Mp", "btr %Ev,%Rv",	403	"cmpxchg %Eb,%Rb", "cmpxchg %Ev,%Rv", "lss %Rv,%Mp", "btr %Ev,%Rv",
404		404
405	"lfs %Rv,%Mp", "lgs %Rv,%Mp", "movzx %Rv,%Eb", "movzx %Rv,%Ew",	405	"lfs %Rv,%Mp", "lgs %Rv,%Mp", "movzx %Rv,%Eb", "movzx %Rv,%Ew",
406		406
407	0, 0, "%g7 %Ev,%Ib", "btc %Ev,%Rv",	407	0, 0, "%g7 %Ev,%Ib", "btc %Ev,%Rv",
408		408
409	"bsf %Rv,%Ev", "bsr %Rv,%Ev", "movsx %Rv,%Eb", "movsx %Rv,%Ew",	409	"bsf %Rv,%Ev", "bsr %Rv,%Ev", "movsx %Rv,%Eb", "movsx %Rv,%Ew",
410		410
411	/* c */	411	/* c */
412		412
413	"xadd %Eb,%Rb", "xadd %Ev,%Rv", "cmpps %RX,%EX,%Ib","movnti %Md,%Rd",	413	"xadd %Eb,%Rb", "xadd %Ev,%Rv", "cmpps %RX,%EX,%Ib","movnti %Md,%Rd",
414		414
415	"pinsrw %LM,%Fd,%Ib","pextrw %Gd,%RM,%Ib","shufps %RX,%EX,%Ib","cmpxchg8b %Myv",	415	"pinsrw %LM,%Fd,%Ib","pextrw %Gd,%RM,%Ib","shufps %RX,%EX,%Ib","cmpxchg8b %Myv",
416		416
417	"bswap eax", "bswap ecx", "bswap edx", "bswap ebx",	417	"bswap eax", "bswap ecx", "bswap edx", "bswap ebx",
418		418
419	"bswap esp", "bswap ebp", "bswap esi", "bswap edi",	419	"bswap esp", "bswap ebp", "bswap esi", "bswap edi",
420		420
421	/* d */	421	/* d */
422		422
423	0, "psrlw %RM,%EM", "psrld %RM,%EM", "psrlq %RM,%EM",	423	0, "psrlw %RM,%EM", "psrld %RM,%EM", "psrlq %RM,%EM",
424		424
425	"paddq %RM,%EM", "pmullw %RM,%EM", 0, "pmovmskb %Rd,%GM",	425	"paddq %RM,%EM", "pmullw %RM,%EM", 0, "pmovmskb %Rd,%GM",
426		426
427	"psubusb %RM,%EM", "psubusw %RM,%EM", "pminub %RM,%EM", "pand %RM,%EM",	427	"psubusb %RM,%EM", "psubusw %RM,%EM", "pminub %RM,%EM", "pand %RM,%EM",
428		428
429	"paddusb %RM,%EM", "paddusw %RM,%EM", "pmaxub %RM,%EM", "pandn %RM,%EM",	429	"paddusb %RM,%EM", "paddusw %RM,%EM", "pmaxub %RM,%EM", "pandn %RM,%EM",
430		430
431	/* e */	431	/* e */
432		432
433	"pavgb %RM,%EM", "psraw %RM,%EM", "psrad %RM,%EM", "pavgw %RM,%EM",	433	"pavgb %RM,%EM", "psraw %RM,%EM", "psrad %RM,%EM", "pavgw %RM,%EM",
434		434
435	"pmulhuw %RM,%EM", "pmulhw %RM,%EM", 0, "movntq %Myv,%RM",	435	"pmulhuw %RM,%EM", "pmulhw %RM,%EM", 0, "movntq %Myv,%RM",
436		436
437	"psubsb %RM,%EM", "psubsw %RM,%EM", "pminsw %RM,%EM", "por %RM,%EM",	437	"psubsb %RM,%EM", "psubsw %RM,%EM", "pminsw %RM,%EM", "por %RM,%EM",
438		438
439	"paddsb %RM,%EM", "paddsw %RM,%EM", "pmaxsw %RM,%EM", "pxor %RM,%EM",	439	"paddsb %RM,%EM", "paddsw %RM,%EM", "pmaxsw %RM,%EM", "pxor %RM,%EM",
440		440
441	/* f */	441	/* f */
442		442
443	0, "psllw %RM,%EM", "pslld %RM,%EM", "psllq %RM,%EM",	443	0, "psllw %RM,%EM", "pslld %RM,%EM", "psllq %RM,%EM",
444		444
445	"pmuludq %RM,%EM", "pmaddwd %RM,%EM", "psadbw %RM,%EM", "maskmovq %GM,%RM",	445	"pmuludq %RM,%EM", "pmaddwd %RM,%EM", "psadbw %RM,%EM", "maskmovq %GM,%RM",
446		446
447	"psubb %RM,%EM", "psubw %RM,%EM", "psubd %RM,%EM", "psubq %RM,%EM",	447	"psubb %RM,%EM", "psubw %RM,%EM", "psubd %RM,%EM", "psubq %RM,%EM",
448		448
449	"paddb %RM,%EM", "paddw %RM,%EM", "paddd %RM,%EM", 0	449	"paddb %RM,%EM", "paddw %RM,%EM", "paddd %RM,%EM", 0
450		450
451	};	451	};
452		452
453		453
454		454
455	char *second_f30f[]={	455	char *second_f30f[]={
456		456
457	// 0	457	// 0
458		458
459	0,0,0,0,0,0,0,0,	459	0,0,0,0,0,0,0,0,
460		460
461	0,0,0,0,0,0,0,0,	461	0,0,0,0,0,0,0,0,
462		462
463	// 1	463	// 1
464		464
465	"movss %RX,%EX","movss %Md,%RX","movsldup %RX,%MX",0,	465	"movss %RX,%EX","movss %Md,%RX","movsldup %RX,%MX",0,
466		466
467	0,0,"movshdup %RX,%MX",0,	467	0,0,"movshdup %RX,%MX",0,
468		468
469	0,0,0,0,0,0,0,0,	469	0,0,0,0,0,0,0,0,
470		470
471	// 2	471	// 2
472		472
473	0,0,0,0,	473	0,0,0,0,
474		474
475	0,0,0,0,	475	0,0,0,0,
476		476
477	0, 0, "cvtsi2ss %RX,%Ed",0,	477	0, 0, "cvtsi2ss %RX,%Ed",0,
478		478
479	"cvttss2si %Rd,%EX","cvtss2si %Rd,%EX",0, 0,	479	"cvttss2si %Rd,%EX","cvtss2si %Rd,%EX",0, 0,
480		480
481	// 3	481	// 3
482		482
483	0,0,0,0,0,0,0,0,	483	0,0,0,0,0,0,0,0,
484		484
485	0,0,0,0,0,0,0,0,	485	0,0,0,0,0,0,0,0,
486		486
487	// 4	487	// 4
488		488
489	0,0,0,0,0,0,0,0,	489	0,0,0,0,0,0,0,0,
490		490
491	0,0,0,0,0,0,0,0,	491	0,0,0,0,0,0,0,0,
492		492
493	// 5	493	// 5
494		494
495	0, "sqrtss %RX,%EX","rsqrtss %RX,%EX", "rcpss %RX,%EX",	495	0, "sqrtss %RX,%EX","rsqrtss %RX,%EX", "rcpss %RX,%EX",
496		496
497	0, 0, 0, 0,	497	0, 0, 0, 0,
498		498
499	"addss %RX,%EX","mulss %RX,%EX", "cvtss2sd %RX,%EX","cvttps2dq %RX,%EX",	499	"addss %RX,%EX","mulss %RX,%EX", "cvtss2sd %RX,%EX","cvttps2dq %RX,%EX",
500		500
501	"subss %RX,%EX","minss %RX,%EX", "divss %RX,%EX", "maxss %RX,%EX",	501	"subss %RX,%EX","minss %RX,%EX", "divss %RX,%EX", "maxss %RX,%EX",
502		502
503	// 6	503	// 6
504		504
505	0,0,0,0,0,0,0,0,	505	0,0,0,0,0,0,0,0,
506		506
507	0,0,0,0,0,0,0,"movdqu %RX,%EX",	507	0,0,0,0,0,0,0,"movdqu %RX,%EX",
508		508
509	// 7	509	// 7
510		510
511	"pshufhw %RX,%EX,%Ib",0,0,0,	511	"pshufhw %RX,%EX,%Ib",0,0,0,
512		512
513	0,0,0,0,	513	0,0,0,0,
514		514
515	0,0,0,0,	515	0,0,0,0,
516		516
517	0,0,"movq %RX,%EX","movdqu %Md,%RX",	517	0,0,"movq %RX,%EX","movdqu %Md,%RX",
518		518
519	// 8	519	// 8
520		520
521	0,0,0,0,0,0,0,0,	521	0,0,0,0,0,0,0,0,
522		522
523	0,0,0,0,0,0,0,0,	523	0,0,0,0,0,0,0,0,
524		524
525	// 9	525	// 9
526		526
527	0,0,0,0,0,0,0,0,	527	0,0,0,0,0,0,0,0,
528		528
529	0,0,0,0,0,0,0,0,	529	0,0,0,0,0,0,0,0,
530		530
531	// a	531	// a
532		532
533	0,0,0,0,0,0,0,0,	533	0,0,0,0,0,0,0,0,
534		534
535	0,0,0,0,0,0,0,0,	535	0,0,0,0,0,0,0,0,
536		536
537	// b	537	// b
538		538
539	0,0,0,0,0,0,0,0,	539	0,0,0,0,0,0,0,0,
540		540
541	0,0,0,0,0,0,0,0,	541	0,0,0,0,0,0,0,0,
542		542
543	// c	543	// c
544		544
545	0,0,"cmpss %RX,%EX,%Ib",0,	545	0,0,"cmpss %RX,%EX,%Ib",0,
546		546
547	0,0,0, 0,	547	0,0,0, 0,
548		548
549	0,0,0, 0,	549	0,0,0, 0,
550		550
551	0,0,0, 0,	551	0,0,0, 0,
552		552
553	// d	553	// d
554		554
555	0,0,0,0,	555	0,0,0,0,
556		556
557	0,0,"movq2dq RX,RM",0,	557	0,0,"movq2dq RX,RM",0,
558		558
559	0,0,0,0,0,0,0,0,	559	0,0,0,0,0,0,0,0,
560		560
561	// e	561	// e
562		562
563	0,0,0,0,	563	0,0,0,0,
564		564
565	0,0,"cvtdq2pd %RX,%EX",0,	565	0,0,"cvtdq2pd %RX,%EX",0,
566		566
567	0,0,0,0,0,0,0,0,	567	0,0,0,0,0,0,0,0,
568		568
569	// f	569	// f
570		570
571	0,0,0,0,0,0,0,0,	571	0,0,0,0,0,0,0,0,
572		572
573	0,0,0,0,0,0,0,0	573	0,0,0,0,0,0,0,0
574		574
575	};	575	};
576		576
577		577
578		578
579	char *second_f20f[]={	579	char *second_f20f[]={
580		580
581	// 0	581	// 0
582		582
583	0,0,0,0,0,0,0,0,	583	0,0,0,0,0,0,0,0,
584		584
585	0,0,0,0,0,0,0,0,	585	0,0,0,0,0,0,0,0,
586		586
587	// 1	587	// 1
588		588
589	"movsd %RX,%Md","movsd %Md,%RX","movddup %RX,%MX",0,	589	"movsd %RX,%Md","movsd %Md,%RX","movddup %RX,%MX",0,
590		590
591	0,0,0,0,	591	0,0,0,0,
592		592
593	0,0,0,0,0,0,0,0,	593	0,0,0,0,0,0,0,0,
594		594
595	// 2	595	// 2
596		596
597	0,0,0,0,	597	0,0,0,0,
598		598
599	0,0,0,0,	599	0,0,0,0,
600		600
601	0,0,"cvtsi2sd %RX,%Md",0,	601	0,0,"cvtsi2sd %RX,%Md",0,
602		602
603	"cvttsd2si %Rd,%EX","cvtsd2si %Rd,%EX",0,0,	603	"cvttsd2si %Rd,%EX","cvtsd2si %Rd,%EX",0,0,
604		604
605	// 3	605	// 3
606		606
607	0,0,0,0,0,0,0,0,	607	0,0,0,0,0,0,0,0,
608		608
609	0,0,0,0,0,0,0,0,	609	0,0,0,0,0,0,0,0,
610		610
611	// 4	611	// 4
612		612
613	0,0,0,0,0,0,0,0,	613	0,0,0,0,0,0,0,0,
614		614
615	0,0,0,0,0,0,0,0,	615	0,0,0,0,0,0,0,0,
616		616
617	// 5	617	// 5
618		618
619	0,"sqrtsd %RX,%EX",0,0,	619	0,"sqrtsd %RX,%EX",0,0,
620		620
621	0,0,0,0,	621	0,0,0,0,
622		622
623	"addsd %RX,%EX","mulsd %RX,%MX","cvtsd2ss %RX,%EX",0,	623	"addsd %RX,%EX","mulsd %RX,%MX","cvtsd2ss %RX,%EX",0,
624		624
625	"subsd %RX,%EX","minsd %RX,%EX","divsd %RX,%EX","maxsd %RX,%EX",	625	"subsd %RX,%EX","minsd %RX,%EX","divsd %RX,%EX","maxsd %RX,%EX",
626		626
627	// 6	627	// 6
628		628
629	0,0,0,0,0,0,0,0,	629	0,0,0,0,0,0,0,0,
630		630
631	0,0,0,0,0,0,0,0,	631	0,0,0,0,0,0,0,0,
632		632
633	// 7	633	// 7
634		634
635	"pshuflw %RX,%EX,%Ib",0,0,0,	635	"pshuflw %RX,%EX,%Ib",0,0,0,
636		636
637	0,0,0,0,	637	0,0,0,0,
638		638
639	0,0,0,0,	639	0,0,0,0,
640		640
641	"haddps %RX,%EX","hsubps %RX,%EX",0,0,	641	"haddps %RX,%EX","hsubps %RX,%EX",0,0,
642		642
643	// 8	643	// 8
644		644
645	0,0,0,0,0,0,0,0,	645	0,0,0,0,0,0,0,0,
646		646
647	0,0,0,0,0,0,0,0,	647	0,0,0,0,0,0,0,0,
648		648
649	// 9	649	// 9
650		650
651	0,0,0,0,0,0,0,0,	651	0,0,0,0,0,0,0,0,
652		652
653	0,0,0,0,0,0,0,0,	653	0,0,0,0,0,0,0,0,
654		654
655	// a	655	// a
656		656
657	0,0,0,0,0,0,0,0,	657	0,0,0,0,0,0,0,0,
658		658
659	0,0,0,0,0,0,0,0,	659	0,0,0,0,0,0,0,0,
660		660
661	// b	661	// b
662		662
663	0,0,0,0,0,0,0,0,	663	0,0,0,0,0,0,0,0,
664		664
665	0,0,0,0,0,0,0,0,	665	0,0,0,0,0,0,0,0,
666		666
667	// c	667	// c
668		668
669	0,0,"cmpsd %RX,%EX,%Ib",0,	669	0,0,"cmpsd %RX,%EX,%Ib",0,
670		670
671	0,0,0,0,	671	0,0,0,0,
672		672
673	0,0,0,0,	673	0,0,0,0,
674		674
675	0,0,0,0,	675	0,0,0,0,
676		676
677	// d	677	// d
678		678
679	"addsubps %RX,%EX",0,0,0,	679	"addsubps %RX,%EX",0,0,0,
680		680
681	0,0,"movdq2q %RM,%RX",0,	681	0,0,"movdq2q %RM,%RX",0,
682		682
683	0,0,0,0,	683	0,0,0,0,
684		684
685	0,0,0,0,	685	0,0,0,0,
686		686
687	// e	687	// e
688		688
689	0,0,0,0,	689	0,0,0,0,
690		690
691	0,0,"cvtpd2dq %RX,%EX",0,	691	0,0,"cvtpd2dq %RX,%EX",0,
692		692
693	0,0,0,0,0,0,0,0,	693	0,0,0,0,0,0,0,0,
694		694
695	// f	695	// f
696		696
697	"lddqu %Md,%RX",0,0,0,	697	"lddqu %Md,%RX",0,0,0,
698		698
699	0,0,0,0,	699	0,0,0,0,
700		700
701	0,0,0,0,	701	0,0,0,0,
702		702
703	0,0,0,0	703	0,0,0,0
704		704
705	};	705	};
706		706
707		707
708		708
709	char *second_660f[]={	709	char *second_660f[]={
710		710
711	// 0	711	// 0
712		712
713	0,0,0,0,	713	0,0,0,0,
714		714
715	0,0,0,0,	715	0,0,0,0,
716		716
717	0,0,0,0,	717	0,0,0,0,
718		718
719	0,0,0,0,	719	0,0,0,0,
720		720
721	// 1	721	// 1
722		722
723	"movupd %RX,%Md","movupd %Md,%RX","movlpd %RX,%Md","movlpd %Md,%RX",	723	"movupd %RX,%Md","movupd %Md,%RX","movlpd %RX,%Md","movlpd %Md,%RX",
724		724
725	"unpcklpd %RX,%EX","unpckhpd %RX,%EX","movhpd %RX,%Md","movhpd %Md,%RX",	725	"unpcklpd %RX,%EX","unpckhpd %RX,%EX","movhpd %RX,%Md","movhpd %Md,%RX",
726		726
727	0,0,0,0,	727	0,0,0,0,
728		728
729	0,0,0,0,	729	0,0,0,0,
730		730
731	// 2	731	// 2
732		732
733	0,0,0,0,	733	0,0,0,0,
734		734
735	0,0,0,0,	735	0,0,0,0,
736		736
737	"movapd %RX,%EX", "movapd %Md,%RX", "cvtpi2pd %RX,%EM","movntpd %Md,%RX",	737	"movapd %RX,%EX", "movapd %Md,%RX", "cvtpi2pd %RX,%EM","movntpd %Md,%RX",
738		738
739	"cvttpd2pi %RM,%EX","cvtpd2pi %RM,%EX","ucomisd %RX,%EX","comisd %RX,%EX",	739	"cvttpd2pi %RM,%EX","cvtpd2pi %RM,%EX","ucomisd %RX,%EX","comisd %RX,%EX",
740		740
741	// 3	741	// 3
742		742
743	0,0,0,0,0,0,0,0,	743	0,0,0,0,0,0,0,0,
744		744
745	0,0,0,0,0,0,0,0,	745	0,0,0,0,0,0,0,0,
746		746
747	// 4	747	// 4
748		748
749	0,0,0,0,0,0,0,0,	749	0,0,0,0,0,0,0,0,
750		750
751	0,0,0,0,0,0,0,0,	751	0,0,0,0,0,0,0,0,
752		752
753	// 5	753	// 5
754		754
755	"movmskpd %Rd,%GX","sqrtpd %RX,%EX",0,0,	755	"movmskpd %Rd,%GX","sqrtpd %RX,%EX",0,0,
756		756
757	"andpd %RX,%EX","andnpd %RX,%EX","orpd %RX,%MX","xorpd %RX,%EX",	757	"andpd %RX,%EX","andnpd %RX,%EX","orpd %RX,%MX","xorpd %RX,%EX",
758		758
759	"addpd %RX,%EX","mulpd %RX,%MX","cvtpd2ps %RX,%EX","cvtps2dq %RX,%EX",	759	"addpd %RX,%EX","mulpd %RX,%MX","cvtpd2ps %RX,%EX","cvtps2dq %RX,%EX",
760		760
761	"subpd %RX,%EX","minpd %RX,%EX","divpd %RX,%EX","maxpd %RX,%EX",	761	"subpd %RX,%EX","minpd %RX,%EX","divpd %RX,%EX","maxpd %RX,%EX",
762		762
763	// 6	763	// 6
764		764
765	"punpcklbw %RX,%EX", "punpcklwd %RX,%EX", "punpckldq %RX,%EX","packsswb %RX,%EX",	765	"punpcklbw %RX,%EX", "punpcklwd %RX,%EX", "punpckldq %RX,%EX","packsswb %RX,%EX",
766		766
767	"pcmpgtb %RX,%EX", "pcmpgtw %RX,%EX", "pcmpgtd %RX,%EX", "packuswb %RX,%EX",	767	"pcmpgtb %RX,%EX", "pcmpgtw %RX,%EX", "pcmpgtd %RX,%EX", "packuswb %RX,%EX",
768		768
769	"punpckhbw %RX,%EX", "punpckhwd %RX,%EX", "punpckhdq %RX,%EX","packssdw %RX,%EX",	769	"punpckhbw %RX,%EX", "punpckhwd %RX,%EX", "punpckhdq %RX,%EX","packssdw %RX,%EX",
770		770
771	"punpcklqdq %RX,%EX","punpckhqdq %RX,%EX","movd %RX,%Md", "movdqa %RX,%EX",	771	"punpcklqdq %RX,%EX","punpckhqdq %RX,%EX","movd %RX,%Md", "movdqa %RX,%EX",
772		772
773	// 7	773	// 7
774		774
775	"pshufd %RX,%EX,%Ib","%g3w %EX,%Ib", "%g3d %EX,%Ib","%g9",	775	"pshufd %RX,%EX,%Ib","%g3w %EX,%Ib", "%g3d %EX,%Ib","%g9",
776		776
777	"pcmpeqb %RX,%EX", "pcmpeqw %RX,%EX", "pcmpeqd %RX,%EX",0,	777	"pcmpeqb %RX,%EX", "pcmpeqw %RX,%EX", "pcmpeqd %RX,%EX",0,
778		778
779	0,0,0,0,	779	0,0,0,0,
780		780
781	"haddpd %RX,%EX","hsubpd %RX,%EX","movd %Md,%RX","movdqa %Md,%RX",	781	"haddpd %RX,%EX","hsubpd %RX,%EX","movd %Md,%RX","movdqa %Md,%RX",
782		782
783	// 8	783	// 8
784		784
785	0,0,0,0,0,0,0,0,	785	0,0,0,0,0,0,0,0,
786		786
787	0,0,0,0,0,0,0,0,	787	0,0,0,0,0,0,0,0,
788		788
789	// 9	789	// 9
790		790
791	0,0,0,0,0,0,0,0,	791	0,0,0,0,0,0,0,0,
792		792
793	0,0,0,0,0,0,0,0,	793	0,0,0,0,0,0,0,0,
794		794
795	// a	795	// a
796		796
797	0,0,0,0,0,0,0,0,	797	0,0,0,0,0,0,0,0,
798		798
799	0,0,0,0,0,0,0,0,	799	0,0,0,0,0,0,0,0,
800		800
801	// b	801	// b
802		802
803	0,0,0,0,0,0,0,0,	803	0,0,0,0,0,0,0,0,
804		804
805	0,0,0,0,0,0,0,0,	805	0,0,0,0,0,0,0,0,
806		806
807	// c	807	// c
808		808
809	0,0,"cmppd %RX,%EX,%Ib",0,	809	0,0,"cmppd %RX,%EX,%Ib",0,
810		810
811	"pinsrw %LX,%Fd,%Ib","pextrw %Gd,%RX,%Ib","shufpd %RX,%EX,%Ib",0,	811	"pinsrw %LX,%Fd,%Ib","pextrw %Gd,%RX,%Ib","shufpd %RX,%EX,%Ib",0,
812		812
813	0,0,0,0,	813	0,0,0,0,
814		814
815	0,0,0,0,	815	0,0,0,0,
816		816
817	// d	817	// d
818		818
819	"addsubpd %RX,%EX","psrlw %RX,%EX", "psrld %RX,%EX", "psrlq %RX,%EX",	819	"addsubpd %RX,%EX","psrlw %RX,%EX", "psrld %RX,%EX", "psrlq %RX,%EX",
820		820
821	"paddq %RX,%EX", "pmullw %RX,%EX", "movq %Md,%RX", "pmovmskb %Rd,%GX",	821	"paddq %RX,%EX", "pmullw %RX,%EX", "movq %Md,%RX", "pmovmskb %Rd,%GX",
822		822
823	"psubusb %RX,%EX", "psubusw %RX,%EX","pminub %RX,%EX","pand %RX,%EX",	823	"psubusb %RX,%EX", "psubusw %RX,%EX","pminub %RX,%EX","pand %RX,%EX",
824		824
825	"paddusb %RX,%EX", "paddusw %RX,%EX","pmaxub %RX,%EX","pandn %RX,%EX",	825	"paddusb %RX,%EX", "paddusw %RX,%EX","pmaxub %RX,%EX","pandn %RX,%EX",
826		826
827	// e	827	// e
828		828
829	"pavgb %RX,%EX", "psraw %RX,%EX", "psrad %RX,%EX", "pavgw %RX,%EX",	829	"pavgb %RX,%EX", "psraw %RX,%EX", "psrad %RX,%EX", "pavgw %RX,%EX",
830		830
831	"pmulhuw %RX,%EX", "pmulhw %RX,%EX","cvttpd2dq %RX,%EX","movntdq %Md,%RX",	831	"pmulhuw %RX,%EX", "pmulhw %RX,%EX","cvttpd2dq %RX,%EX","movntdq %Md,%RX",
832		832
833	"psubsb %RX,%EX", "psubsw %RX,%EX","pminsw %RX,%EX", "por %RX,%EX",	833	"psubsb %RX,%EX", "psubsw %RX,%EX","pminsw %RX,%EX", "por %RX,%EX",
834		834
835	"paddsb %RX,%EX", "paddsw %RX,%EX","pmaxsw %RX,%EX", "pxor %RX,%EX",	835	"paddsb %RX,%EX", "paddsw %RX,%EX","pmaxsw %RX,%EX", "pxor %RX,%EX",
836		836
837	// f	837	// f
838		838
839	0, "psllw %RX,%EX", "pslld %RX,%EX", "psllq %RX,%EX",	839	0, "psllw %RX,%EX", "pslld %RX,%EX", "psllq %RX,%EX",
840		840
841	"pmuludq %RX,%EX", "pmaddwd %RX,%EX","psadbw %RX,%EX","maskmovdqu %RX,%RX",	841	"pmuludq %RX,%EX", "pmaddwd %RX,%EX","psadbw %RX,%EX","maskmovdqu %RX,%RX",
842		842
843	"psubb %RX,%EX", "psubw %RX,%EX", "psubd %RX,%EX", "psubq %RX,%EX",	843	"psubb %RX,%EX", "psubw %RX,%EX", "psubd %RX,%EX", "psubq %RX,%EX",
844		844
845	"paddb %RX,%EX", "paddw %RX,%EX", "paddd %RX,%EX", 0	845	"paddb %RX,%EX", "paddw %RX,%EX", "paddd %RX,%EX", 0
846		846
847	};	847	};
848		848
849		849
850		850
851	char groups[][8] = { / group 0 is group 3 for %Ev set */	851	char groups[][8] = { / group 0 is group 3 for %Ev set */
852		852
853	/* 0 */	853	/* 0 */
854		854
855	{ "add", "or", "adc", "sbb",	855	{ "add", "or", "adc", "sbb",
856		856
857	"and", "sub", "xor", "cmp" },	857	"and", "sub", "xor", "cmp" },
858		858
859	/* 1 */	859	/* 1 */
860		860
861	{ "rol", "ror", "rcl", "rcr",	861	{ "rol", "ror", "rcl", "rcr",
862		862
863	"shl", "shr", "shl", "sar" },	863	"shl", "shr", "shl", "sar" },
864		864
865	/* 2 / / v v*/	865	/* 2 / / v v*/
866		866
867	{ "test %Eq,%Iq", 0/"test %Eq,%Iq"/, "not %Ec", "neg %Ec",	867	{ "test %Eq,%Iq", 0/"test %Eq,%Iq"/, "not %Ec", "neg %Ec",
868		868
869	"mul %Ec", "imul %Ec", "div %Ec", "idiv %Ec" },	869	"mul %Ec", "imul %Ec", "div %Ec", "idiv %Ec" },
870		870
871	/* 3 */	871	/* 3 */
872		872
873	{ "inc %Eb", "dec %Eb", "psrl", 0,	873	{ "inc %Eb", "dec %Eb", "psrl", 0,
874		874
875	"psra", 0, "psll", 0 },	875	"psra", 0, "psll", 0 },
876		876
877	/* 4 */	877	/* 4 */
878		878
879	{ "inc %Ev", "dec %Ev", "call %Kn%Ev", "call %Kf%Ep",	879	{ "inc %Ev", "dec %Ev", "call %Kn%Ev", "call %Kf%Ep",
880		880
881	"jmp %Kn%Ev", "jmp %Kf%Ep", "push %Ev", 0 },	881	"jmp %Kn%Ev", "jmp %Kf%Ep", "push %Ev", 0 },
882		882
883	/* 5 */	883	/* 5 */
884		884
885	{ "sldt %Ew", "str %Ew", "lldt %Ew", "ltr %Ew",	885	{ "sldt %Ew", "str %Ew", "lldt %Ew", "ltr %Ew",
886		886
887	"verr %Ew", "verw %Ew", 0, 0 },	887	"verr %Ew", "verw %Ew", 0, 0 },
888		888
889	/* 6 */	889	/* 6 */
890		890
891	{ "sgdt %Ms", "sidt %Ms", "lgdt %Ms", "lidt %Ms",	891	{ "sgdt %Ms", "sidt %Ms", "lgdt %Ms", "lidt %Ms",
892		892
893	"smsw %Ew", 0, "lmsw %Ew", "invlpg %Em" },	893	"smsw %Ew", 0, "lmsw %Ew", "invlpg %Em" },
894		894
895	/* 7 */	895	/* 7 */
896		896
897	{ "prefetchnta %Em","prefetcht0 %Em", "prefetcht1 %Em", "prefetcht2 %Em",	897	{ "prefetchnta %Em","prefetcht0 %Em", "prefetcht1 %Em", "prefetcht2 %Em",
898		898
899	"bt", "bts", "btr", "btc" },	899	"bt", "bts", "btr", "btc" },
900		900
901	/* 8 */	901	/* 8 */
902		902
903	{ "fxsave %Em", "fxrstor %Em", "ldmxcsr %Em", "stmxcsr %Em",	903	{ "fxsave %Em", "fxrstor %Em", "ldmxcsr %Em", "stmxcsr %Em",
904		904
905	0, "lfence", "mfence", "%x2" },	905	0, "lfence", "mfence", "%x2" },
906		906
907	/* 9 */	907	/* 9 */
908		908
909	{	909	{
910		910
911	0,0,"psrlq %RX,%Ib","psrldq %RX,%Ib",	911	0,0,"psrlq %RX,%Ib","psrldq %RX,%Ib",
912		912
913	0,0,"psllq %RX,%Ib","pslldq %RX,%Ib"	913	0,0,"psllq %RX,%Ib","pslldq %RX,%Ib"
914		914
915	}	915	}
916		916
917		917
918		918
919	};	919	};
920		920
921		921
922		922
923	/* zero here means invalid. If first entry starts with '', use st(i) /	923	/* zero here means invalid. If first entry starts with '', use st(i) /
924		924
925	/* no assumed %EFs here. Indexed by RM(modrm()) */	925	/* no assumed %EFs here. Indexed by RM(modrm()) */
926		926
927	char *f0[] = { 0, 0, 0, 0, 0, 0, 0, 0};	927	char *f0[] = { 0, 0, 0, 0, 0, 0, 0, 0};
928		928
929	char fop_9[] = { "fxch st,%GF",0,0,0,0,0,0,0 };	929	char fop_9[] = { "fxch st,%GF",0,0,0,0,0,0,0 };
930		930
931	char *fop_10[] = { "fnop", 0, 0, 0, 0, 0, 0, 0 };	931	char *fop_10[] = { "fnop", 0, 0, 0, 0, 0, 0, 0 };
932		932
933	char *fop_12[] = { "fchs", "fabs", 0, 0, "ftst", "fxam", 0, 0 };	933	char *fop_12[] = { "fchs", "fabs", 0, 0, "ftst", "fxam", 0, 0 };
934		934
935	char *fop_13[] = { "fld1", "fldl2t", "fldl2e", "fldpi",	935	char *fop_13[] = { "fld1", "fldl2t", "fldl2e", "fldpi",
936		936
937	"fldlg2", "fldln2", "fldz", 0 };	937	"fldlg2", "fldln2", "fldz", 0 };
938		938
939	char *fop_14[] = { "f2xm1", "fyl2x", "fptan", "fpatan",	939	char *fop_14[] = { "f2xm1", "fyl2x", "fptan", "fpatan",
940		940
941	"fxtract", "fprem1", "fdecstp", "fincstp" };	941	"fxtract", "fprem1", "fdecstp", "fincstp" };
942		942
943	char *fop_15[] = { "fprem", "fyl2xp1", "fsqrt", "fsincos",	943	char *fop_15[] = { "fprem", "fyl2xp1", "fsqrt", "fsincos",
944		944
945	"frndint", "fscale", "fsin", "fcos" };	945	"frndint", "fscale", "fsin", "fcos" };
946		946
947	char *fop_21[] = { 0, "fucompp", 0, 0, 0, 0, 0, 0 };	947	char *fop_21[] = { 0, "fucompp", 0, 0, 0, 0, 0, 0 };
948		948
949	char *fop_28[] = { "fneni", "fndisi", "fnclex", "fninit", "fnsetpm", 0, 0, 0 };	949	char *fop_28[] = { "fneni", "fndisi", "fnclex", "fninit", "fnsetpm", 0, 0, 0 };
950		950
951	char fop_32[] = { "fadd %GF,st",0,0,0,0,0,0,0 };	951	char fop_32[] = { "fadd %GF,st",0,0,0,0,0,0,0 };
952		952
953	char fop_33[] = { "fmul %GF,st",0,0,0,0,0,0,0 };	953	char fop_33[] = { "fmul %GF,st",0,0,0,0,0,0,0 };
954		954
955	char fop_36[] = { "fsubr %GF,st",0,0,0,0,0,0,0 };	955	char fop_36[] = { "fsubr %GF,st",0,0,0,0,0,0,0 };
956		956
957	char fop_37[] = { "fsub %GF,st",0,0,0,0,0,0,0 };	957	char fop_37[] = { "fsub %GF,st",0,0,0,0,0,0,0 };
958		958
959	char fop_38[] = { "fdivr %GF,st",0,0,0,0,0,0,0 };	959	char fop_38[] = { "fdivr %GF,st",0,0,0,0,0,0,0 };
960		960
961	char fop_39[] = { "fdiv %GF,st",0,0,0,0,0,0,0 };	961	char fop_39[] = { "fdiv %GF,st",0,0,0,0,0,0,0 };
962		962
963	char fop_40[] = { "ffree %GF",0,0,0,0,0,0,0 };	963	char fop_40[] = { "ffree %GF",0,0,0,0,0,0,0 };
964		964
965	char fop_42[] = { "fst %GF",0,0,0,0,0,0,0 };	965	char fop_42[] = { "fst %GF",0,0,0,0,0,0,0 };
966		966
967	char fop_43[] = { "fstp %GF",0,0,0,0,0,0,0 };	967	char fop_43[] = { "fstp %GF",0,0,0,0,0,0,0 };
968		968
969	char fop_44[] = { "fucom %GF",0,0,0,0,0,0,0 };	969	char fop_44[] = { "fucom %GF",0,0,0,0,0,0,0 };
970		970
971	char fop_45[] = { "fucomp %GF",0,0,0,0,0,0,0 };	971	char fop_45[] = { "fucomp %GF",0,0,0,0,0,0,0 };
972		972
973	char fop_48[] = { "faddp %GF,st",0,0,0,0,0,0,0 };	973	char fop_48[] = { "faddp %GF,st",0,0,0,0,0,0,0 };
974		974
975	char fop_49[] = { "fmulp %GF,st",0,0,0,0,0,0,0 };	975	char fop_49[] = { "fmulp %GF,st",0,0,0,0,0,0,0 };
976		976
977	char *fop_51[] = { 0, "fcompp", 0, 0, 0, 0, 0, 0 };	977	char *fop_51[] = { 0, "fcompp", 0, 0, 0, 0, 0, 0 };
978		978
979	char fop_52[] = { "fsubrp %GF,st",0,0,0,0,0,0,0 };	979	char fop_52[] = { "fsubrp %GF,st",0,0,0,0,0,0,0 };
980		980
981	char fop_53[] = { "fsubp %GF,st",0,0,0,0,0,0,0 };	981	char fop_53[] = { "fsubp %GF,st",0,0,0,0,0,0,0 };
982		982
983	char fop_54[] = { "fdivrp %GF,st",0,0,0,0,0,0,0 };	983	char fop_54[] = { "fdivrp %GF,st",0,0,0,0,0,0,0 };
984		984
985	char fop_55[] = { "fdivp %GF,st",0,0,0,0,0,0,0 };	985	char fop_55[] = { "fdivp %GF,st",0,0,0,0,0,0,0 };
986		986
987	char *fop_60[] = { "fnstsw ax", 0, 0, 0, 0, 0, 0, 0 };	987	char *fop_60[] = { "fnstsw ax", 0, 0, 0, 0, 0, 0, 0 };
988		988
989	char fop_16[]={"fcmovb st,%GF",0,0,0,0,0,0,0};	989	char fop_16[]={"fcmovb st,%GF",0,0,0,0,0,0,0};
990		990
991	char fop_17[]={"fcmove st,%GF",0,0,0,0,0,0,0};	991	char fop_17[]={"fcmove st,%GF",0,0,0,0,0,0,0};
992		992
993	char fop_18[]={"fcmovbe st,%GF",0,0,0,0,0,0,0};	993	char fop_18[]={"fcmovbe st,%GF",0,0,0,0,0,0,0};
994		994
995	char fop_19[]={"fcmovu st,%GF",0,0,0,0,0,0,0};	995	char fop_19[]={"fcmovu st,%GF",0,0,0,0,0,0,0};
996		996
997	char fop_24[]={"fcmovnb st,%GF",0,0,0,0,0,0,0};	997	char fop_24[]={"fcmovnb st,%GF",0,0,0,0,0,0,0};
998		998
999	char fop_25[]={"fcmovne st,%GF",0,0,0,0,0,0,0};	999	char fop_25[]={"fcmovne st,%GF",0,0,0,0,0,0,0};
1000		1000
1001	char fop_26[]={"fcmovnbe st,%GF",0,0,0,0,0,0,0};	1001	char fop_26[]={"fcmovnbe st,%GF",0,0,0,0,0,0,0};
1002		1002
1003	char fop_27[]={"fcmovnu st,%GF",0,0,0,0,0,0,0};	1003	char fop_27[]={"fcmovnu st,%GF",0,0,0,0,0,0,0};
1004		1004
1005	char fop_29[]={"fucomi st,%GF",0,0,0,0,0,0,0};	1005	char fop_29[]={"fucomi st,%GF",0,0,0,0,0,0,0};
1006		1006
1007	char fop_30[]={"fcomi st,%GF",0,0,0,0,0,0,0};	1007	char fop_30[]={"fcomi st,%GF",0,0,0,0,0,0,0};
1008		1008
1009	char fop_61[]={"fucomip st,%GF",0,0,0,0,0,0,0};	1009	char fop_61[]={"fucomip st,%GF",0,0,0,0,0,0,0};
1010		1010
1011	char fop_62[]={"fcomip st,%GF",0,0,0,0,0,0,0};	1011	char fop_62[]={"fcomip st,%GF",0,0,0,0,0,0,0};
1012		1012
1013		1013
1014		1014
1015	char *fspecial[] = { / 0=use st(i), 1=undefined 0 in fop_* means undefined */	1015	char *fspecial[] = { / 0=use st(i), 1=undefined 0 in fop_* means undefined */
1016		1016
1017	0, 0, 0, 0, 0, 0, 0, 0,	1017	0, 0, 0, 0, 0, 0, 0, 0,
1018		1018
1019	0, fop_9, fop_10, 0, fop_12, fop_13, fop_14, fop_15,	1019	0, fop_9, fop_10, 0, fop_12, fop_13, fop_14, fop_15,
1020		1020
1021	fop_16, fop_17, fop_18, fop_19, f0, fop_21, f0, f0,	1021	fop_16, fop_17, fop_18, fop_19, f0, fop_21, f0, f0,
1022		1022
1023	fop_24, fop_25, fop_26, fop_27, fop_28, fop_29, fop_30, f0,	1023	fop_24, fop_25, fop_26, fop_27, fop_28, fop_29, fop_30, f0,
1024		1024
1025	fop_32, fop_33, f0, f0, fop_36, fop_37, fop_38, fop_39,	1025	fop_32, fop_33, f0, f0, fop_36, fop_37, fop_38, fop_39,
1026		1026
1027	fop_40, f0, fop_42, fop_43, fop_44, fop_45, f0, f0,	1027	fop_40, f0, fop_42, fop_43, fop_44, fop_45, f0, f0,
1028		1028
1029	fop_48, fop_49, f0, fop_51, fop_52, fop_53, fop_54, fop_55,	1029	fop_48, fop_49, f0, fop_51, fop_52, fop_53, fop_54, fop_55,
1030		1030
1031	f0, f0, f0, f0, fop_60, fop_61, fop_62, f0	1031	f0, f0, f0, f0, fop_60, fop_61, fop_62, f0
1032		1032
1033	};	1033	};
1034		1034
1035		1035
1036		1036
1037	char floatops[] = { / assumed " %EF" at end of each. mod != 3 only */	1037	char floatops[] = { / assumed " %EF" at end of each. mod != 3 only */
1038		1038
1039	/00/ "fadd", "fmul", "fcom", "fcomp",	1039	/00/ "fadd", "fmul", "fcom", "fcomp",
1040		1040
1041	"fsub", "fsubr", "fdiv", "fdivr",	1041	"fsub", "fsubr", "fdiv", "fdivr",
1042		1042
1043	/08/ "fld", 0, "fst", "fstp",	1043	/08/ "fld", 0, "fst", "fstp",
1044		1044
1045	"fldenv", "fldcw", "fnstenv", "fnstcw",	1045	"fldenv", "fldcw", "fnstenv", "fnstcw",
1046		1046
1047	/16/ "fiadd", "fimul", "ficomw", "ficompw",	1047	/16/ "fiadd", "fimul", "ficomw", "ficompw",
1048		1048
1049	"fisub", "fisubr", "fidiv", "fidivr",	1049	"fisub", "fisubr", "fidiv", "fidivr",
1050		1050
1051	/24/ "fild", 0, "fist", "fistp",	1051	/24/ "fild", 0, "fist", "fistp",
1052		1052
1053	"frstor", "fldt", 0, "fstpt",	1053	"frstor", "fldt", 0, "fstpt",
1054		1054
1055	/32/ "faddq", "fmulq", "fcomq", "fcompq",	1055	/32/ "faddq", "fmulq", "fcomq", "fcompq",
1056		1056
1057	"fsubq", "fsubrq", "fdivq", "fdivrq",	1057	"fsubq", "fsubrq", "fdivq", "fdivrq",
1058		1058
1059	/40/ "fldq", 0, "fstq", "fstpq",	1059	/40/ "fldq", 0, "fstq", "fstpq",
1060		1060
1061	0, 0, "fnsave", "fnstsw",	1061	0, 0, "fnsave", "fnstsw",
1062		1062
1063	/48/ "fiaddw", "fimulw", "ficomw", "ficompw",	1063	/48/ "fiaddw", "fimulw", "ficomw", "ficompw",
1064		1064
1065	"fisubw", "fisubrw", "fidivw", "fidivr",	1065	"fisubw", "fisubrw", "fidivw", "fidivr",
1066		1066
1067	/56/ "fildw", 0, "fistw", "fistpw",	1067	/56/ "fildw", 0, "fistw", "fistpw",
1068		1068
1069	"fbldt", "fildq", "fbstpt", "fistpq"	1069	"fbldt", "fildq", "fbstpt", "fistpq"
1070		1070
1071	};	1071	};
1072		1072
1073		1073
1074		1074
1075	/* variables controlled by command line flags */	1075	/* variables controlled by command line flags */
1076		1076
1077	unsigned char seg_size=16; /* default size is 16 */	1077	unsigned char seg_size=16; /* default size is 16 */
1078		1078
1079	unsigned char must_do_size;	1079	unsigned char must_do_size;
1080		1080
1081		1081
1082		1082
1083	unsigned int wordop,qwordop; /* dealing with word or byte operand */	1083	unsigned int wordop,qwordop; /* dealing with word or byte operand */
1084		1084
1085	unsigned long instruction_offset;	1085	unsigned long instruction_offset;
1086		1086
1087	unsigned short done_space; /* for opcodes with > one space */	1087	unsigned short done_space; /* for opcodes with > one space */
1088		1088
1089		1089
1090		1090
1091	char ubuf[100],*ubufp;	1091	char ubuf[100],*ubufp;
1092		1092
1093	int col; /* output column */	1093	int col; /* output column */
1094		1094
1095	unsigned int prefix; /* segment override prefix byte */	1095	unsigned int prefix; /* segment override prefix byte */
1096		1096
1097	unsigned int modrmv; /* flag for getting modrm byte */	1097	unsigned int modrmv; /* flag for getting modrm byte */
1098		1098
1099	unsigned int sibv; /* flag for getting sib byte */	1099	unsigned int sibv; /* flag for getting sib byte */
1100		1100
1101	unsigned int opsize; /* just like it says ... */	1101	unsigned int opsize; /* just like it says ... */
1102		1102
1103	unsigned int addrsize;	1103	unsigned int addrsize;
1104		1104
1105		1105
1106		1106
1107	void printbyte(unsigned char c)	1107	void printbyte(unsigned char c)
1108		1108
1109	{	1109	{
1110		1110
1111	if(c<10)uprintf("%u",(unsigned char)c);	1111	if(c<10)uprintf("%u",(unsigned char)c);
1112		1112
1113	else if(c<16\|\|c>0x9F)uprintf("0%Xh",(unsigned char)c);	1113	else if(c<16\|\|c>0x9F)uprintf("0%Xh",(unsigned char)c);
1114		1114
1115	else uprintf("%Xh",(unsigned char)c);	1115	else uprintf("%Xh",(unsigned char)c);
1116		1116
1117	}	1117	}
1118		1118
1119		1119
1120		1120
1121	void printword(unsigned short c)	1121	void printword(unsigned short c)
1122		1122
1123	{	1123	{
1124		1124
1125	if(c<256)printbyte(c);	1125	if(c<256)printbyte(c);
1126		1126
1127	else if(c<0xA00\|\|(c>0xFFF&&c<0xA000))uprintf("%Xh",c);	1127	else if(c<0xA00\|\|(c>0xFFF&&c<0xA000))uprintf("%Xh",c);
1128		1128
1129	else uprintf("0%Xh",c);	1129	else uprintf("0%Xh",c);
1130		1130
1131	}	1131	}
1132		1132
1133		1133
1134		1134
1135	void printdword(unsigned int c)	1135	void printdword(unsigned int c)
1136		1136
1137	{	1137	{
1138		1138
1139	if(c<65536)printword((unsigned short)c);	1139	if(c<65536)printword((unsigned short)c);
1140		1140
1141	else if(c<0xA0000L\|\|(c>0xFFFFFL&&c<0xA00000L)\|\|(c>0xFFFFFFL&&c<0xA000000L)\|\|	1141	else if(c<0xA0000L\|\|(c>0xFFFFFL&&c<0xA00000L)\|\|(c>0xFFFFFFL&&c<0xA000000L)\|\|
1142		1142
1143	(c>0xFFFFFFFL&&c<0xA0000000L))uprintf("%lXh",c);	1143	(c>0xFFFFFFFL&&c<0xA0000000L))uprintf("%lXh",c);
1144		1144
1145	else uprintf("0%lXh",c);	1145	else uprintf("0%lXh",c);
1146		1146
1147	}	1147	}
1148		1148
1149		1149
1150		1150
1151	void addr_to_hex(long addr, unsigned char splitup)	1151	void addr_to_hex(long addr, unsigned char splitup)
1152		1152
1153	{	1153	{
1154		1154
1155	static char buffer[11];	1155	static char buffer[12]; // fix by cppcheck
1156		1156
1157	WORD32 adr;	1157	WORD32 adr;
1158		1158
1159	adr.dword=addr;	1159	adr.dword=addr;
1160		1160
1161	if(splitup){	1161	if(splitup){
1162		1162
1163	if(adr.w.seg==0/\|\|adr.w.seg==0xffff/)printword(adr.w.ofs);//sprintf(buffer,"%04Xh",adr.w.ofs);	1163	if(adr.w.seg==0/\|\|adr.w.seg==0xffff/)printword(adr.w.ofs);//sprintf(buffer,"%04Xh",adr.w.ofs);
1164		1164
1165	else{	1165	else{
1166		1166
1167	sprintf(buffer,"%04Xh:%04Xh",adr.w.seg,adr.w.ofs);	1167	sprintf(buffer,"%04Xh:%04Xh",adr.w.seg,adr.w.ofs);
1168		1168
1169	uprintf("%s",buffer);	1169	uprintf("%s",buffer);
1170		1170
1171	}	1171	}
1172		1172
1173	}	1173	}
1174		1174
1175	else{	1175	else{
1176		1176
1177	if(adr.w.seg==0/\|\|adr.w.seg==0xffff/)printword(adr.w.ofs);//sprintf(buffer,"%04Xh",adr.w.ofs);	1177	if(adr.w.seg==0/\|\|adr.w.seg==0xffff/)printword(adr.w.ofs);//sprintf(buffer,"%04Xh",adr.w.ofs);
1178		1178
1179	else printdword(addr);//sprintf(buffer, "%08lXh",addr);	1179	else printdword(addr);//sprintf(buffer, "%08lXh",addr);
1180		1180
1181	}	1181	}
1182		1182
1183	}	1183	}
1184		1184
1185		1185
1186		1186
1187	unsigned char getbyte(void)	1187	unsigned char getbyte(void)
1188		1188
1189	{	1189	{
1190		1190
1191	short c;	1191	short c;
1192		1192
1193	c=output[outptr++];	1193	c=output[outptr++];
1194		1194
1195	fprintf(hout,"%02X", c); /* print out byte */	1195	fprintf(hout,"%02X", c); /* print out byte */
1196		1196
1197	col+=2;	1197	col+=2;
1198		1198
1199	instruction_offset++;	1199	instruction_offset++;
1200		1200
1201	return c;	1201	return c;
1202		1202
1203	}	1203	}
1204		1204
1205		1205
1206		1206
1207	int modrm()	1207	int modrm()
1208		1208
1209	{	1209	{
1210		1210
1211	if (modrmv == -1) modrmv = getbyte();	1211	if (modrmv == -1) modrmv = getbyte();
1212		1212
1213	return modrmv;	1213	return modrmv;
1214		1214
1215	}	1215	}
1216		1216
1217		1217
1218		1218
1219	int sib()	1219	int sib()
1220		1220
1221	{	1221	{
1222		1222
1223	if (sibv == -1) sibv = getbyte();	1223	if (sibv == -1) sibv = getbyte();
1224		1224
1225	return sibv;	1225	return sibv;
1226		1226
1227	}	1227	}
1228		1228
1229		1229
1230		1230
1231	/------------------------------------------------------------------------/	1231	/------------------------------------------------------------------------/
1232		1232
1233	void uprintf(char *s, ...)	1233	void uprintf(char *s, ...)
1234		1234
1235	{	1235	{
1236		1236
1237	va_list argptr;	1237	va_list argptr;
1238		1238
1239	va_start(argptr,s);	1239	va_start(argptr,s);
1240		1240
1241	vsprintf(ubufp,s,argptr);	1241	vsprintf(ubufp,s,argptr);
1242		1242
1243	va_end(argptr);	1243	va_end(argptr);
1244		1244
1245	while (*ubufp) ubufp++;	1245	while (*ubufp) ubufp++;
1246		1246
1247	}	1247	}
1248		1248
1249		1249
1250		1250
1251	void uputchar(char c)	1251	void uputchar(char c)
1252		1252
1253	{	1253	{
1254		1254
1255	if (c == '\t') {	1255	if (c == '\t') {
1256		1256
1257	if(done_space)uputchar(' ');	1257	if(done_space)uputchar(' ');
1258		1258
1259	else {	1259	else {
1260		1260
1261	done_space=1;	1261	done_space=1;
1262		1262
1263	do {	1263	do {
1264		1264
1265	*ubufp++ = ' ';	1265	*ubufp++ = ' ';
1266		1266
1267	} while ((ubufp-ubuf) % 8);	1267	} while ((ubufp-ubuf) % 8);
1268		1268
1269	}	1269	}
1270		1270
1271	}	1271	}
1272		1272
1273	else *ubufp++ = c;	1273	else *ubufp++ = c;
1274		1274
1275	*ubufp = 0;	1275	*ubufp = 0;
1276		1276
1277	}	1277	}
1278		1278
1279		1279
1280		1280
1281	/------------------------------------------------------------------------/	1281	/------------------------------------------------------------------------/
1282		1282
1283	int bytes(char c)	1283	int bytes(char c)
1284		1284
1285	{	1285	{
1286		1286
1287	switch (c){	1287	switch (c){
1288		1288
1289	case 'b': return 1;	1289	case 'b': return 1;
1290		1290
1291	case 'w': return 2;	1291	case 'w': return 2;
1292		1292
1293	case 'd': return 4;	1293	case 'd': return 4;
1294		1294
1295	case 'v':	1295	case 'v':
1296		1296
1297	if (opsize == 32) return 4;	1297	if (opsize == 32) return 4;
1298		1298
1299	else return 2;	1299	else return 2;
1300		1300
1301	}	1301	}
1302		1302
1303	return 0;	1303	return 0;
1304		1304
1305	}	1305	}
1306		1306
1307		1307
1308		1308
1309	/------------------------------------------------------------------------/	1309	/------------------------------------------------------------------------/
1310		1310
1311	void outhex(char subtype, int extend, int optional, int defsize, int sign)	1311	void outhex(char subtype, int extend, int optional, int defsize, int sign)
1312		1312
1313	{	1313	{
1314		1314
1315	int n=0, s=0, i;	1315	int n=0, s=0, i;
1316		1316
1317	long delta;	1317	long delta;
1318		1318
1319	unsigned char buff[6];	1319	unsigned char buff[6];
1320		1320
1321	//char *name;	1321	//char *name;
1322		1322
1323	char signchar;	1323	char signchar;
1324		1324
1325	switch (subtype) {	1325	switch (subtype) {
1326		1326
1327	case 'q':	1327	case 'q':
1328		1328
1329	if (wordop) {	1329	if (wordop) {
1330		1330
1331	if (opsize==16) n = 2;	1331	if (opsize==16) n = 2;
1332		1332
1333	else n = 4;	1333	else n = 4;
1334		1334
1335	}	1335	}
1336		1336
1337	else n = 1;	1337	else n = 1;
1338		1338
1339	break;	1339	break;
1340		1340
1341		1341
1342		1342
1343	case 'a': break;	1343	case 'a': break;
1344		1344
1345	case 'x':	1345	case 'x':
1346		1346
1347	extend = defsize/8;//2;	1347	extend = defsize/8;//2;
1348		1348
1349	n = 1;	1349	n = 1;
1350		1350
1351	break;	1351	break;
1352		1352
1353	case 'b':	1353	case 'b':
1354		1354
1355	n = 1;	1355	n = 1;
1356		1356
1357	break;	1357	break;
1358		1358
1359	case 'w':	1359	case 'w':
1360		1360
1361	n = 2;	1361	n = 2;
1362		1362
1363	break;	1363	break;
1364		1364
1365	case 'd':	1365	case 'd':
1366		1366
1367	n = 4;	1367	n = 4;
1368		1368
1369	break;	1369	break;
1370		1370
1371	case 's':	1371	case 's':
1372		1372
1373	n = 6;	1373	n = 6;
1374		1374
1375	break;	1375	break;
1376		1376
1377	case 'c':	1377	case 'c':
1378		1378
1379	case 'v':	1379	case 'v':
1380		1380
1381	if (defsize == 32) n = 4;	1381	if (defsize == 32) n = 4;
1382		1382
1383	else n = 2;	1383	else n = 2;
1384		1384
1385	break;	1385	break;
1386		1386
1387	case 'p':	1387	case 'p':
1388		1388
1389	if (defsize == 32) n = 6;	1389	if (defsize == 32) n = 6;
1390		1390
1391	else n = 4;	1391	else n = 4;
1392		1392
1393	s = 1;	1393	s = 1;
1394		1394
1395	break;	1395	break;
1396		1396
1397	}	1397	}
1398		1398
1399	for (i=0; i	1399	for (i=0; i
1400		1400
1401	for(;i	1401	for(;i
1402		1402
1403	if (s) {	1403	if (s) {
1404		1404
1405	uprintf("%02X%02X:", buff[n-1], buff[n-2]);	1405	uprintf("%02X%02X:", buff[n-1], buff[n-2]);
1406		1406
1407	n -= 2;	1407	n -= 2;
1408		1408
1409	}	1409	}
1410		1410
1411	switch (n) {	1411	switch (n) {
1412		1412
1413	case 1:	1413	case 1:
1414		1414
1415	delta = (signed char )buff;	1415	delta = (signed char )buff;
1416		1416
1417	break;	1417	break;
1418		1418
1419	case 2:	1419	case 2:
1420		1420
1421	delta = (signed short )buff;	1421	delta = (signed short )buff;
1422		1422
1423	break;	1423	break;
1424		1424
1425	case 4:	1425	case 4:
1426		1426
1427	delta = (signed long )buff;	1427	delta = (signed long )buff;
1428		1428
1429	break;	1429	break;
1430		1430
1431	}	1431	}
1432		1432
1433	if (extend > n) {	1433	if (extend > n) {
1434		1434
1435	if (subtype!='x') {	1435	if (subtype!='x') {
1436		1436
1437	if ((long)delta<0) {	1437	if ((long)delta<0) {
1438		1438
1439	delta = -delta;	1439	delta = -delta;
1440		1440
1441	signchar = '-';	1441	signchar = '-';
1442		1442
1443	}	1443	}
1444		1444
1445	else signchar = '+';	1445	else signchar = '+';
1446		1446
1447	if (delta \|\| !optional){	1447	if (delta \|\| !optional){
1448		1448
1449	uprintf("%c",signchar);	1449	uprintf("%c",signchar);
1450		1450
1451	printdword(delta);	1451	printdword(delta);
1452		1452
1453	// uprintf("%c%0*lXh", signchar, extend+1, delta);	1453	// uprintf("%c%0*lXh", signchar, extend+1, delta);
1454		1454
1455	}	1455	}
1456		1456
1457	}	1457	}
1458		1458
1459	else {	1459	else {
1460		1460
1461	if (extend==2)	1461	if (extend==2)
1462		1462
1463	delta = (unsigned short) delta;	1463	delta = (unsigned short) delta;
1464		1464
1465	printdword(delta);	1465	printdword(delta);
1466		1466
1467	// uprintf("%0.lXh", 2extend+1, delta);	1467	// uprintf("%0.lXh", 2extend+1, delta);
1468		1468
1469	}	1469	}
1470		1470
1471	return;	1471	return;
1472		1472
1473	}	1473	}
1474		1474
1475	if ((n == 4) && !sign) {	1475	if ((n == 4) && !sign) {
1476		1476
1477	addr_to_hex(delta, 0);	1477	addr_to_hex(delta, 0);
1478		1478
1479	return;	1479	return;
1480		1480
1481	}	1481	}
1482		1482
1483	switch (n) {	1483	switch (n) {
1484		1484
1485	case 1:	1485	case 1:
1486		1486
1487	if (sign && (char)delta<0) {	1487	if (sign && (char)delta<0) {
1488		1488
1489	delta = -delta;	1489	delta = -delta;
1490		1490
1491	signchar = '-';	1491	signchar = '-';
1492		1492
1493	}	1493	}
1494		1494
1495	else signchar = '+';	1495	else signchar = '+';
1496		1496
1497	if(sign)uprintf("%c",signchar);	1497	if(sign)uprintf("%c",signchar);
1498		1498
1499	printbyte((unsigned char)delta);	1499	printbyte((unsigned char)delta);
1500		1500
1501	// if (sign)uprintf("%c%03Xh",signchar,(unsigned char)delta);	1501	// if (sign)uprintf("%c%03Xh",signchar,(unsigned char)delta);
1502		1502
1503	// else uprintf("%03Xh", (unsigned char)delta);	1503	// else uprintf("%03Xh", (unsigned char)delta);
1504		1504
1505	break;	1505	break;
1506		1506
1507	case 2:	1507	case 2:
1508		1508
1509	if (sign && (int)delta<0) {	1509	if (sign && (int)delta<0) {
1510		1510
1511	signchar = '-';	1511	signchar = '-';
1512		1512
1513	delta = -delta;	1513	delta = -delta;
1514		1514
1515	}	1515	}
1516		1516
1517	else signchar = '+';	1517	else signchar = '+';
1518		1518
1519	if(sign)uprintf("%c",signchar);	1519	if(sign)uprintf("%c",signchar);
1520		1520
1521	printword((unsigned short)delta);	1521	printword((unsigned short)delta);
1522		1522
1523	// if (sign) uprintf("%c%05Xh", signchar,(int)delta);	1523	// if (sign) uprintf("%c%05Xh", signchar,(int)delta);
1524		1524
1525	// else uprintf("%05Xh", (unsigned int)delta);	1525	// else uprintf("%05Xh", (unsigned int)delta);
1526		1526
1527	break;	1527	break;
1528		1528
1529	case 4:	1529	case 4:
1530		1530
1531	if (sign && (long)delta<0) {	1531	if (sign && (long)delta<0) {
1532		1532
1533	delta = -delta;	1533	delta = -delta;
1534		1534
1535	signchar = '-';	1535	signchar = '-';
1536		1536
1537	}	1537	}
1538		1538
1539	else signchar = '+';	1539	else signchar = '+';
1540		1540
1541	if(sign)uprintf("%c",signchar);	1541	if(sign)uprintf("%c",signchar);
1542		1542
1543	printdword(delta);	1543	printdword(delta);
1544		1544
1545	// if (sign)uprintf("%c%09lXh", signchar, (unsigned long)delta);	1545	// if (sign)uprintf("%c%09lXh", signchar, (unsigned long)delta);
1546		1546
1547	// else uprintf("%09lXh", (unsigned long)delta);	1547	// else uprintf("%09lXh", (unsigned long)delta);
1548		1548
1549	break;	1549	break;
1550		1550
1551	}	1551	}
1552		1552
1553	}	1553	}
1554		1554
1555		1555
1556		1556
1557	/------------------------------------------------------------------------/	1557	/------------------------------------------------------------------------/
1558		1558
1559	void reg_name(int regnum, char size)	1559	void reg_name(int regnum, char size)
1560		1560
1561	{	1561	{
1562		1562
1563	if (size == 'F') { /* floating point register? */	1563	if (size == 'F') { /* floating point register? */
1564		1564
1565	uprintf("st(%d)", regnum);	1565	uprintf("st(%d)", regnum);
1566		1566
1567	return;	1567	return;
1568		1568
1569	}	1569	}
1570		1570
1571	if (size == 'M') { /* multimedia register? */	1571	if (size == 'M') { /* multimedia register? */
1572		1572
1573	uprintf("mm%d", regnum);	1573	uprintf("mm%d", regnum);
1574		1574
1575	return;	1575	return;
1576		1576
1577	}	1577	}
1578		1578
1579	if(size=='X'){ /* xmm register? */	1579	if(size=='X'){ /* xmm register? */
1580		1580
1581	uprintf("xmm%d",regnum);	1581	uprintf("xmm%d",regnum);
1582		1582
1583	return;	1583	return;
1584		1584
1585	}	1585	}
1586		1586
1587	if (((size == 'v') && (opsize == 32)) \|\|	1587	if (((size == 'v') && (opsize == 32)) \|\|
1588		1588
1589	(size == 'd')\|\|	1589	(size == 'd')\|\|
1590		1590
1591	((size=='c'\|\|size=='q')&&wordop&&opsize==32)	1591	((size=='c'\|\|size=='q')&&wordop&&opsize==32)
1592		1592
1593	) uputchar('e');	1593	) uputchar('e');
1594		1594
1595	// printf("size=%c wordop=%d opsize=%d\n",size,wordop,opsize);	1595	// printf("size=%c wordop=%d opsize=%d\n",size,wordop,opsize);
1596		1596
1597	if(size=='b'\|\|((size=='q'\|\|size=='c')&&!wordop)){	1597	if(size=='b'\|\|((size=='q'\|\|size=='c')&&!wordop)){
1598		1598
1599	uputchar("acdbacdb"[regnum]);	1599	uputchar("acdbacdb"[regnum]);
1600		1600
1601	uputchar("llllhhhh"[regnum]);	1601	uputchar("llllhhhh"[regnum]);
1602		1602
1603	}	1603	}
1604		1604
1605	else {	1605	else {
1606		1606
1607	uputchar("acdbsbsd"[regnum]);	1607	uputchar("acdbsbsd"[regnum]);
1608		1608
1609	uputchar("xxxxppii"[regnum]);	1609	uputchar("xxxxppii"[regnum]);
1610		1610
1611	}	1611	}
1612		1612
1613	}	1613	}
1614		1614
1615		1615
1616		1616
1617	/------------------------------------------------------------------------/	1617	/------------------------------------------------------------------------/
1618		1618
1619	void do_sib(int m)	1619	void do_sib(int m)
1620		1620
1621	{	1621	{
1622		1622
1623	int s, i, b;	1623	int s, i, b;
1624		1624
1625	s = SCALE(sib());	1625	s = SCALE(sib());
1626		1626
1627	i = INDEX(sib());	1627	i = INDEX(sib());
1628		1628
1629	b = BASE(sib());	1629	b = BASE(sib());
1630		1630
1631	switch (b) { /* pick base */	1631	switch (b) { /* pick base */
1632		1632
1633	case 0: ua_str("%p:[eax"); break;	1633	case 0: ua_str("%p:[eax"); break;
1634		1634
1635	case 1: ua_str("%p:[ecx"); break;	1635	case 1: ua_str("%p:[ecx"); break;
1636		1636
1637	case 2: ua_str("%p:[edx"); break;	1637	case 2: ua_str("%p:[edx"); break;
1638		1638
1639	case 3: ua_str("%p:[ebx"); break;	1639	case 3: ua_str("%p:[ebx"); break;
1640		1640
1641	case 4: ua_str("%p:[esp"); break;	1641	case 4: ua_str("%p:[esp"); break;
1642		1642
1643	case 5:	1643	case 5:
1644		1644
1645	if (m == 0) {	1645	if (m == 0) {
1646		1646
1647	ua_str("%p:[");	1647	ua_str("%p:[");
1648		1648
1649	outhex('d', 4, 0, addrsize, 0);	1649	outhex('d', 4, 0, addrsize, 0);
1650		1650
1651	}	1651	}
1652		1652
1653	else ua_str("%p:[ebp");	1653	else ua_str("%p:[ebp");
1654		1654
1655	break;	1655	break;
1656		1656
1657	case 6: ua_str("%p:[esi"); break;	1657	case 6: ua_str("%p:[esi"); break;
1658		1658
1659	case 7: ua_str("%p:[edi"); break;	1659	case 7: ua_str("%p:[edi"); break;
1660		1660
1661	}	1661	}
1662		1662
1663	switch (i) { /* and index */	1663	switch (i) { /* and index */
1664		1664
1665	case 0: uprintf("+eax"); break;	1665	case 0: uprintf("+eax"); break;
1666		1666
1667	case 1: uprintf("+ecx"); break;	1667	case 1: uprintf("+ecx"); break;
1668		1668
1669	case 2: uprintf("+edx"); break;	1669	case 2: uprintf("+edx"); break;
1670		1670
1671	case 3: uprintf("+ebx"); break;	1671	case 3: uprintf("+ebx"); break;
1672		1672
1673	case 4: break;	1673	case 4: break;
1674		1674
1675	case 5: uprintf("+ebp"); break;	1675	case 5: uprintf("+ebp"); break;
1676		1676
1677	case 6: uprintf("+esi"); break;	1677	case 6: uprintf("+esi"); break;
1678		1678
1679	case 7: uprintf("+edi"); break;	1679	case 7: uprintf("+edi"); break;
1680		1680
1681	}	1681	}
1682		1682
1683	if (i != 4) {	1683	if (i != 4) {
1684		1684
1685	switch (s) { /* and scale */	1685	switch (s) { /* and scale */
1686		1686
1687	case 0: uprintf(""); break;	1687	case 0: uprintf(""); break;
1688		1688
1689	case 1: uprintf("*2"); break;	1689	case 1: uprintf("*2"); break;
1690		1690
1691	case 2: uprintf("*4"); break;	1691	case 2: uprintf("*4"); break;
1692		1692
1693	case 3: uprintf("*8"); break;	1693	case 3: uprintf("*8"); break;
1694		1694
1695	}	1695	}
1696		1696
1697	}	1697	}
1698		1698
1699	}	1699	}
1700		1700
1701		1701
1702		1702
1703	/------------------------------------------------------------------------/	1703	/------------------------------------------------------------------------/
1704		1704
1705	void do_modrm(char subtype)	1705	void do_modrm(char subtype)
1706		1706
1707	{	1707	{
1708		1708
1709	int mod = MOD(modrm());	1709	int mod = MOD(modrm());
1710		1710
1711	int rm = RM(modrm());	1711	int rm = RM(modrm());
1712		1712
1713	int extend = (addrsize == 32) ? 4 : 2;	1713	int extend = (addrsize == 32) ? 4 : 2;
1714		1714
1715	if (mod == 3) { /* specifies two registers */	1715	if (mod == 3) { /* specifies two registers */
1716		1716
1717	reg_name(rm, subtype);	1717	reg_name(rm, subtype);
1718		1718
1719	return;	1719	return;
1720		1720
1721	}	1721	}
1722		1722
1723	if (must_do_size) {	1723	if (must_do_size) {
1724		1724
1725	if(qwordop)ua_str("qword ptr ");	1725	if(qwordop)ua_str("qword ptr ");
1726		1726
1727	else{	1727	else{
1728		1728
1729	if (wordop) {	1729	if (wordop) {
1730		1730
1731	if (/addrsize==32 \|\|/ opsize==32) { /* then must specify size */	1731	if (/addrsize==32 \|\|/ opsize==32) { /* then must specify size */
1732		1732
1733	ua_str("dword ptr ");	1733	ua_str("dword ptr ");
1734		1734
1735	}	1735	}
1736		1736
1737	else ua_str("word ptr ");	1737	else ua_str("word ptr ");
1738		1738
1739	}	1739	}
1740		1740
1741	else ua_str("byte ptr ");	1741	else ua_str("byte ptr ");
1742		1742
1743	}	1743	}
1744		1744
1745	}	1745	}
1746		1746
1747	if ((mod == 0) && (rm == 5) && (addrsize == 32)) {/* mem operand with 32 bit ofs */	1747	if ((mod == 0) && (rm == 5) && (addrsize == 32)) {/* mem operand with 32 bit ofs */
1748		1748
1749	ua_str("%p:[");	1749	ua_str("%p:[");
1750		1750
1751	outhex('d', extend, 0, addrsize, 0);	1751	outhex('d', extend, 0, addrsize, 0);
1752		1752
1753	uputchar(']');	1753	uputchar(']');
1754		1754
1755	return;	1755	return;
1756		1756
1757	}	1757	}
1758		1758
1759	if ((mod == 0) && (rm == 6) && (addrsize == 16)) { /* 16 bit dsplcmnt */	1759	if ((mod == 0) && (rm == 6) && (addrsize == 16)) { /* 16 bit dsplcmnt */
1760		1760
1761	ua_str("%p:[");	1761	ua_str("%p:[");
1762		1762
1763	outhex('w', extend, 0, addrsize, 0);	1763	outhex('w', extend, 0, addrsize, 0);
1764		1764
1765	uputchar(']');	1765	uputchar(']');
1766		1766
1767	return;	1767	return;
1768		1768
1769	}	1769	}
1770		1770
1771	if ((addrsize != 32) \|\| (rm != 4)) ua_str("%p:[");	1771	if ((addrsize != 32) \|\| (rm != 4)) ua_str("%p:[");
1772		1772
1773	if (addrsize == 16) {	1773	if (addrsize == 16) {
1774		1774
1775	switch (rm) {	1775	switch (rm) {
1776		1776
1777	case 0: uprintf("bx+si"); break;	1777	case 0: uprintf("bx+si"); break;
1778		1778
1779	case 1: uprintf("bx+di"); break;	1779	case 1: uprintf("bx+di"); break;
1780		1780
1781	case 2: uprintf("bp+si"); break;	1781	case 2: uprintf("bp+si"); break;
1782		1782
1783	case 3: uprintf("bp+di"); break;	1783	case 3: uprintf("bp+di"); break;
1784		1784
1785	case 4: uprintf("si"); break;	1785	case 4: uprintf("si"); break;
1786		1786
1787	case 5: uprintf("di"); break;	1787	case 5: uprintf("di"); break;
1788		1788
1789	case 6: uprintf("bp"); break;	1789	case 6: uprintf("bp"); break;
1790		1790
1791	case 7: uprintf("bx"); break;	1791	case 7: uprintf("bx"); break;
1792		1792
1793	}	1793	}
1794		1794
1795	}	1795	}
1796		1796
1797	else {	1797	else {
1798		1798
1799	switch (rm) {	1799	switch (rm) {
1800		1800
1801	case 0: uprintf("eax"); break;	1801	case 0: uprintf("eax"); break;
1802		1802
1803	case 1: uprintf("ecx"); break;	1803	case 1: uprintf("ecx"); break;
1804		1804
1805	case 2: uprintf("edx"); break;	1805	case 2: uprintf("edx"); break;
1806		1806
1807	case 3: uprintf("ebx"); break;	1807	case 3: uprintf("ebx"); break;
1808		1808
1809	case 4: do_sib(mod); break;	1809	case 4: do_sib(mod); break;
1810		1810
1811	case 5: uprintf("ebp"); break;	1811	case 5: uprintf("ebp"); break;
1812		1812
1813	case 6: uprintf("esi"); break;	1813	case 6: uprintf("esi"); break;
1814		1814
1815	case 7: uprintf("edi"); break;	1815	case 7: uprintf("edi"); break;
1816		1816
1817	}	1817	}
1818		1818
1819	}	1819	}
1820		1820
1821	switch (mod) {	1821	switch (mod) {
1822		1822
1823	case 1:	1823	case 1:
1824		1824
1825	outhex('b', extend, 1, addrsize, 0);	1825	outhex('b', extend, 1, addrsize, 0);
1826		1826
1827	break;	1827	break;
1828		1828
1829	case 2:	1829	case 2:
1830		1830
1831	outhex('v', extend, 1, addrsize, 1);	1831	outhex('v', extend, 1, addrsize, 1);
1832		1832
1833	break;	1833	break;
1834		1834
1835	}	1835	}
1836		1836
1837	uputchar(']');	1837	uputchar(']');
1838		1838
1839	}	1839	}
1840		1840
1841		1841
1842		1842
1843	/------------------------------------------------------------------------/	1843	/------------------------------------------------------------------------/
1844		1844
1845	void floating_point(int e1)	1845	void floating_point(int e1)
1846		1846
1847	{	1847	{
1848		1848
1849	int esc = e1*8 + REG(modrm());	1849	int esc = e1*8 + REG(modrm());
1850		1850
1851	if(MOD(modrm())==3){ //2- >C0	1851	if(MOD(modrm())==3){ //2- >C0
1852		1852
1853	if (fspecial[esc]) {	1853	if (fspecial[esc]) {
1854		1854
1855	if (fspecial[esc][0]!=NULL&&fspecial[esc][0][0] == '*')ua_str(fspecial[esc][0]+1);	1855	if (fspecial[esc][0]!=NULL&&fspecial[esc][0][0] == '*')ua_str(fspecial[esc][0]+1);
1856		1856
1857	else ua_str(fspecial[esc][RM(modrm())]);	1857	else ua_str(fspecial[esc][RM(modrm())]);
1858		1858
1859	}	1859	}
1860		1860
1861	else {	1861	else {
1862		1862
1863	ua_str(floatops[esc]);	1863	ua_str(floatops[esc]);
1864		1864
1865	ua_str(" %EF");	1865	ua_str(" %EF");
1866		1866
1867	}	1867	}
1868		1868
1869	}	1869	}
1870		1870
1871	else {	1871	else {
1872		1872
1873	ua_str(floatops[esc]);	1873	ua_str(floatops[esc]);
1874		1874
1875	ua_str(" %EF");	1875	ua_str(" %EF");
1876		1876
1877	}	1877	}
1878		1878
1879	}	1879	}
1880		1880
1881		1881
1882		1882
1883	/------------------------------------------------------------------------/	1883	/------------------------------------------------------------------------/
1884		1884
1885	/* Main table driver */	1885	/* Main table driver */
1886		1886
1887	void percent(char type, char subtype)	1887	void percent(char type, char subtype)
1888		1888
1889	{	1889	{
1890		1890
1891	long vofs;	1891	long vofs;
1892		1892
1893	int extend =(addrsize==32)?4:2;	1893	int extend =(addrsize==32)?4:2;
1894		1894
1895	unsigned char c;	1895	unsigned char c;
1896		1896
1897	switch (type) {	1897	switch (type) {
1898		1898
1899	case 'A': /* direct address */	1899	case 'A': /* direct address */
1900		1900
1901	outhex(subtype,extend,0,addrsize,0);	1901	outhex(subtype,extend,0,addrsize,0);
1902		1902
1903	break;	1903	break;
1904		1904
1905	case 'C': /* reg(r/m) picks control reg */	1905	case 'C': /* reg(r/m) picks control reg */
1906		1906
1907	uprintf("CR%d",REG(modrm()));	1907	uprintf("CR%d",REG(modrm()));
1908		1908
1909	must_do_size=0;	1909	must_do_size=0;
1910		1910
1911	break;	1911	break;
1912		1912
1913	case 'D': /* reg(r/m) picks debug reg */	1913	case 'D': /* reg(r/m) picks debug reg */
1914		1914
1915	uprintf("DR%d", REG(modrm()));	1915	uprintf("DR%d", REG(modrm()));
1916		1916
1917	must_do_size = 0;	1917	must_do_size = 0;
1918		1918
1919	break;	1919	break;
1920		1920
1921	case 'E': /* r/m picks operand */	1921	case 'E': /* r/m picks operand */
1922		1922
1923	if(subtype=='m')must_do_size=0;	1923	if(subtype=='m')must_do_size=0;
1924		1924
1925	do_modrm(subtype);	1925	do_modrm(subtype);
1926		1926
1927	break;	1927	break;
1928		1928
1929	case 'F':	1929	case 'F':
1930		1930
1931	if(MOD(modrm())!=3)do_modrm(subtype);	1931	if(MOD(modrm())!=3)do_modrm(subtype);
1932		1932
1933	else reg_name(REG(modrm()),subtype);	1933	else reg_name(REG(modrm()),subtype);
1934		1934
1935	break;	1935	break;
1936		1936
1937	case 'G': /* reg(r/m) picks register */	1937	case 'G': /* reg(r/m) picks register */
1938		1938
1939	/* if (subtype == 'F'\|\|subtype == 'M')	1939	/* if (subtype == 'F'\|\|subtype == 'M')
1940		1940
1941	reg_name(RM(modrm()), subtype);	1941	reg_name(RM(modrm()), subtype);
1942		1942
1943	else reg_name(REG(modrm()), subtype);*/	1943	else reg_name(REG(modrm()), subtype);*/
1944		1944
1945	reg_name(RM(modrm()),subtype);	1945	reg_name(RM(modrm()),subtype);
1946		1946
1947	must_do_size = 0;	1947	must_do_size = 0;
1948		1948
1949	break;	1949	break;
1950		1950
1951	case 'I': /* immed data */	1951	case 'I': /* immed data */
1952		1952
1953	outhex(subtype, 0, 0, opsize, 0);	1953	outhex(subtype, 0, 0, opsize, 0);
1954		1954
1955	break;	1955	break;
1956		1956
1957	case 'J': /* relative IP offset */	1957	case 'J': /* relative IP offset */
1958		1958
1959	switch(bytes(subtype)) { /* sizeof offset value */	1959	switch(bytes(subtype)) { /* sizeof offset value */
1960		1960
1961	case 1:	1961	case 1:
1962		1962
1963	vofs=(signed char)getbyte();	1963	vofs=(signed char)getbyte();
1964		1964
1965	break;	1965	break;
1966		1966
1967	case 2:	1967	case 2:
1968		1968
1969	vofs = getbyte();	1969	vofs = getbyte();
1970		1970
1971	vofs += getbyte()<<8;	1971	vofs += getbyte()<<8;
1972		1972
1973	vofs = (short)vofs;	1973	vofs = (short)vofs;
1974		1974
1975	break;	1975	break;
1976		1976
1977	case 4:	1977	case 4:
1978		1978
1979	vofs = (unsigned long)getbyte(); /* yuk! */	1979	vofs = (unsigned long)getbyte(); /* yuk! */
1980		1980
1981	vofs \|= (unsigned long)getbyte() << 8;	1981	vofs \|= (unsigned long)getbyte() << 8;
1982		1982
1983	vofs \|= (unsigned long)getbyte() << 16;	1983	vofs \|= (unsigned long)getbyte() << 16;
1984		1984
1985	vofs \|= (unsigned long)getbyte() << 24;	1985	vofs \|= (unsigned long)getbyte() << 24;
1986		1986
1987	break;	1987	break;
1988		1988
1989	}	1989	}
1990		1990
1991	addr_to_hex(vofs+instruction_offset,seg_size==16?(unsigned char)1:(unsigned char)0);	1991	addr_to_hex(vofs+instruction_offset,seg_size==16?(unsigned char)1:(unsigned char)0);
1992		1992
1993	break;	1993	break;
1994		1994
1995	case 'K':	1995	case 'K':
1996		1996
1997	if(seg_size==16){	1997	if(seg_size==16){
1998		1998
1999	switch(subtype){	1999	switch(subtype){
2000		2000
2001	case 'f':	2001	case 'f':
2002		2002
2003	ua_str("far ");	2003	ua_str("far ");
2004		2004
2005	break;	2005	break;
2006		2006
2007	case 'n':	2007	case 'n':
2008		2008
2009	ua_str("near ");	2009	ua_str("near ");
2010		2010
2011	break;	2011	break;
2012		2012
2013	case 's':	2013	case 's':
2014		2014
2015	ua_str("short ");	2015	ua_str("short ");
2016		2016
2017	break;	2017	break;
2018		2018
2019	}	2019	}
2020		2020
2021	}	2021	}
2022		2022
2023	else if(subtype=='s')ua_str("short ");	2023	else if(subtype=='s')ua_str("short ");
2024		2024
2025	break;	2025	break;
2026		2026
2027	case 'L':	2027	case 'L':
2028		2028
2029	if(MOD(modrm())!=3)reg_name(REG(modrm()),subtype);	2029	if(MOD(modrm())!=3)reg_name(REG(modrm()),subtype);
2030		2030
2031	else reg_name(RM(modrm()),subtype);	2031	else reg_name(RM(modrm()),subtype);
2032		2032
2033	break;	2033	break;
2034		2034
2035	case 'M': /* r/m picks memory */	2035	case 'M': /* r/m picks memory */
2036		2036
2037	do_modrm(subtype);	2037	do_modrm(subtype);
2038		2038
2039	break;	2039	break;
2040		2040
2041	case 'O': /* offset only */	2041	case 'O': /* offset only */
2042		2042
2043	ua_str("%p:[");	2043	ua_str("%p:[");
2044		2044
2045	outhex(subtype, extend, 0, addrsize, 0);	2045	outhex(subtype, extend, 0, addrsize, 0);
2046		2046
2047	uputchar(']');	2047	uputchar(']');
2048		2048
2049	break;	2049	break;
2050		2050
2051	case 'P': /* prefix byte (rh) */	2051	case 'P': /* prefix byte (rh) */
2052		2052
2053	ua_str("%p:");	2053	ua_str("%p:");
2054		2054
2055	break;	2055	break;
2056		2056
2057	case 'R': /* mod(r/m) picks register */	2057	case 'R': /* mod(r/m) picks register */
2058		2058
2059	reg_name(REG(modrm()), subtype); /* rh */	2059	reg_name(REG(modrm()), subtype); /* rh */
2060		2060
2061	must_do_size = 0;	2061	must_do_size = 0;
2062		2062
2063	break;	2063	break;
2064		2064
2065	case 'S': /* reg(r/m) picks segment reg */	2065	case 'S': /* reg(r/m) picks segment reg */
2066		2066
2067	uputchar("ecsdfg"[REG(modrm())]);	2067	uputchar("ecsdfg"[REG(modrm())]);
2068		2068
2069	uputchar('s');	2069	uputchar('s');
2070		2070
2071	must_do_size = 0;	2071	must_do_size = 0;
2072		2072
2073	break;	2073	break;
2074		2074
2075	case 'T': /* reg(r/m) picks T reg */	2075	case 'T': /* reg(r/m) picks T reg */
2076		2076
2077	uprintf("tr%d", REG(modrm()));	2077	uprintf("tr%d", REG(modrm()));
2078		2078
2079	must_do_size = 0;	2079	must_do_size = 0;
2080		2080
2081	break;	2081	break;
2082		2082
2083	case 'X': /* ds:si type operator */	2083	case 'X': /* ds:si type operator */
2084		2084
2085	uprintf("ds:[");	2085	uprintf("ds:[");
2086		2086
2087	if (addrsize == 32) uputchar('e');	2087	if (addrsize == 32) uputchar('e');
2088		2088
2089	uprintf("si]");	2089	uprintf("si]");
2090		2090
2091	break;	2091	break;
2092		2092
2093	case 'Y': /* es:di type operator */	2093	case 'Y': /* es:di type operator */
2094		2094
2095	uprintf("es:[");	2095	uprintf("es:[");
2096		2096
2097	if (addrsize == 32) uputchar('e');	2097	if (addrsize == 32) uputchar('e');
2098		2098
2099	uprintf("di]");	2099	uprintf("di]");
2100		2100
2101	break;	2101	break;
2102		2102
2103	case '2':	2103	case '2':
2104		2104
2105	c=getbyte(); /* old [pop cs]! now indexes */	2105	c=getbyte(); /* old [pop cs]! now indexes */
2106		2106
2107	wordop = c & 1;	2107	wordop = c & 1;
2108		2108
2109	ua_str(second[c]); /* instructions in 386/486 */	2109	ua_str(second[c]); /* instructions in 386/486 */
2110		2110
2111	break;	2111	break;
2112		2112
2113	case 'd': /* sizeof operand==dword? */	2113	case 'd': /* sizeof operand==dword? */
2114		2114
2115	if (opsize == 32) uputchar('d');	2115	if (opsize == 32) uputchar('d');
2116		2116
2117	uputchar(subtype);	2117	uputchar(subtype);
2118		2118
2119	break;	2119	break;
2120		2120
2121	case 'e': /* extended reg name */	2121	case 'e': /* extended reg name */
2122		2122
2123	if (opsize == 32) {	2123	if (opsize == 32) {
2124		2124
2125	if (subtype == 'w')uputchar('d');	2125	if (subtype == 'w')uputchar('d');
2126		2126
2127	else {	2127	else {
2128		2128
2129	uputchar('e');	2129	uputchar('e');
2130		2130
2131	uputchar(subtype);	2131	uputchar(subtype);
2132		2132
2133	}	2133	}
2134		2134
2135	}	2135	}
2136		2136
2137	else uputchar(subtype);	2137	else uputchar(subtype);
2138		2138
2139	break;	2139	break;
2140		2140
2141	case 'f': /* '87 opcode */	2141	case 'f': /* '87 opcode */
2142		2142
2143	floating_point(subtype-'0');	2143	floating_point(subtype-'0');
2144		2144
2145	break;	2145	break;
2146		2146
2147	case 'j':	2147	case 'j':
2148		2148
2149	if (/addrsize==32 \|\|/ opsize==32) /* both of them?! */	2149	if (/addrsize==32 \|\|/ opsize==32) /* both of them?! */
2150		2150
2151	uputchar('e');	2151	uputchar('e');
2152		2152
2153	break;	2153	break;
2154		2154
2155	case 'g': /* modrm group `subtype' (0--7) */	2155	case 'g': /* modrm group `subtype' (0--7) */
2156		2156
2157	switch(subtype){	2157	switch(subtype){
2158		2158
2159	case '9':	2159	case '9':
2160		2160
2161	vofs=REG(modrm());	2161	vofs=REG(modrm());
2162		2162
2163	modrmv=(modrmv&0xC7)\|((modrmv&7)<<3);	2163	modrmv=(modrmv&0xC7)\|((modrmv&7)<<3);
2164		2164
2165	ua_str(groups[9][vofs]);	2165	ua_str(groups[9][vofs]);
2166		2166
2167	break;	2167	break;
2168		2168
2169	case '6':	2169	case '6':
2170		2170
2171	if(MOD(modrm())!=3)goto defg;	2171	if(MOD(modrm())!=3)goto defg;
2172		2172
2173	switch(modrmv){	2173	switch(modrmv){
2174		2174
2175	case 0xc8:	2175	case 0xc8:
2176		2176
2177	ua_str("monitor");	2177	ua_str("monitor");
2178		2178
2179	break;	2179	break;
2180		2180
2181	case 0xc9:	2181	case 0xc9:
2182		2182
2183	ua_str("mwait");	2183	ua_str("mwait");
2184		2184
2185	break;	2185	break;
2186		2186
2187	default:	2187	default:
2188		2188
2189	uprintf("");	2189	uprintf("");
2190		2190
2191	break;	2191	break;
2192		2192
2193	}	2193	}
2194		2194
2195	break;	2195	break;
2196		2196
2197	case '5':	2197	case '5':
2198		2198
2199	opsize=16;	2199	opsize=16;
2200		2200
2201	case '7':	2201	case '7':
2202		2202
2203	wordop=1;	2203	wordop=1;
2204		2204
2205	default:	2205	default:
2206		2206
2207	defg:	2207	defg:
2208		2208
2209	ua_str(groups[subtype-'0'][REG(modrm())]);	2209	ua_str(groups[subtype-'0'][REG(modrm())]);
2210		2210
2211	break;	2211	break;
2212		2212
2213	}	2213	}
2214		2214
2215	break;	2215	break;
2216		2216
2217	case 'p': /* prefix byte */	2217	case 'p': /* prefix byte */
2218		2218
2219	switch (subtype) {	2219	switch (subtype) {
2220		2220
2221	case 'c':	2221	case 'c':
2222		2222
2223	case 'd':	2223	case 'd':
2224		2224
2225	case 'e':	2225	case 'e':
2226		2226
2227	case 'f':	2227	case 'f':
2228		2228
2229	case 'g':	2229	case 'g':
2230		2230
2231	case 's':	2231	case 's':
2232		2232
2233	prefix = subtype;	2233	prefix = subtype;
2234		2234
2235	c = getbyte();	2235	c = getbyte();
2236		2236
2237	wordop = c & 1;	2237	wordop = c & 1;
2238		2238
2239	ua_str(opmap1[c]);	2239	ua_str(opmap1[c]);
2240		2240
2241	break;	2241	break;
2242		2242
2243	case ':':	2243	case ':':
2244		2244
2245	if (prefix) uprintf("%cs:", prefix);	2245	if (prefix) uprintf("%cs:", prefix);
2246		2246
2247	break;	2247	break;
2248		2248
2249	case ' ':	2249	case ' ':
2250		2250
2251	c = getbyte();	2251	c = getbyte();
2252		2252
2253	wordop = c & 1;	2253	wordop = c & 1;
2254		2254
2255	ua_str(opmap1[c]);	2255	ua_str(opmap1[c]);
2256		2256
2257	break;	2257	break;
2258		2258
2259	}	2259	}
2260		2260
2261	break;	2261	break;
2262		2262
2263	case 's': /* size override */	2263	case 's': /* size override */
2264		2264
2265	switch (subtype) {	2265	switch (subtype) {
2266		2266
2267	case 'a':	2267	case 'a':
2268		2268
2269	addrsize = 48 - addrsize;	2269	addrsize = 48 - addrsize;
2270		2270
2271	c = getbyte();	2271	c = getbyte();
2272		2272
2273	wordop = c & 1;	2273	wordop = c & 1;
2274		2274
2275	ua_str(opmap1[c]);	2275	ua_str(opmap1[c]);
2276		2276
2277	break;	2277	break;
2278		2278
2279	case 'o':	2279	case 'o':
2280		2280
2281	opsize = 48 - opsize;	2281	opsize = 48 - opsize;
2282		2282
2283	c = getbyte();	2283	c = getbyte();
2284		2284
2285	wordop = c & 1;	2285	wordop = c & 1;
2286		2286
2287	ua_str(opmap1[c]);	2287	ua_str(opmap1[c]);
2288		2288
2289	break;	2289	break;
2290		2290
2291	}	2291	}
2292		2292
2293	break;	2293	break;
2294		2294
2295	case 'w': /* insert explicit size specifier */	2295	case 'w': /* insert explicit size specifier */
2296		2296
2297	if (opsize == 32)uputchar('d');	2297	if (opsize == 32)uputchar('d');
2298		2298
2299	else uputchar('w');	2299	else uputchar('w');
2300		2300
2301	uputchar(subtype);	2301	uputchar(subtype);
2302		2302
2303	break;	2303	break;
2304		2304
2305	case 'x':	2305	case 'x':
2306		2306
2307	if(MOD(modrm())==3){	2307	if(MOD(modrm())==3){
2308		2308
2309	switch(subtype-'0'){	2309	switch(subtype-'0'){
2310		2310
2311	case 0:	2311	case 0:
2312		2312
2313	ua_str("movhlps %RX,%GX");	2313	ua_str("movhlps %RX,%GX");
2314		2314
2315	break;	2315	break;
2316		2316
2317	case 1:	2317	case 1:
2318		2318
2319	ua_str("movlhps %RX,%GX");	2319	ua_str("movlhps %RX,%GX");
2320		2320
2321	break;	2321	break;
2322		2322
2323	case 2:	2323	case 2:
2324		2324
2325	ua_str("sfence");	2325	ua_str("sfence");
2326		2326
2327	break;	2327	break;
2328		2328
2329	}	2329	}
2330		2330
2331	}	2331	}
2332		2332
2333	else{	2333	else{
2334		2334
2335	switch(subtype-'0'){	2335	switch(subtype-'0'){
2336		2336
2337	case 0:	2337	case 0:
2338		2338
2339	ua_str("movlps %RX,%Md");	2339	ua_str("movlps %RX,%Md");
2340		2340
2341	break;	2341	break;
2342		2342
2343	case 1:	2343	case 1:
2344		2344
2345	ua_str("movhps %RX,%Md");	2345	ua_str("movhps %RX,%Md");
2346		2346
2347	break;	2347	break;
2348		2348
2349	case 2:	2349	case 2:
2350		2350
2351	ua_str("clflush %Em");	2351	ua_str("clflush %Em");
2352		2352
2353	break;	2353	break;
2354		2354
2355	}	2355	}
2356		2356
2357	}	2357	}
2358		2358
2359	break;	2359	break;
2360		2360
2361	default:	2361	default:
2362		2362
2363	preerror("uncnown operand for dizassemler");	2363	preerror("uncnown operand for dizassemler");
2364		2364
2365	break;	2365	break;
2366		2366
2367	}	2367	}
2368		2368
2369	}	2369	}
2370		2370
2371		2371
2372		2372
2373	void ua_str(char *str)	2373	void ua_str(char *str)
2374		2374
2375	{	2375	{
2376		2376
2377	char c;	2377	char c;
2378		2378
2379	if (str == NULL) {	2379	if (str == NULL) {
2380		2380
2381	uprintf("");	2381	uprintf("");
2382		2382
2383	return;	2383	return;
2384		2384
2385	}	2385	}
2386		2386
2387	if (strpbrk(str, "CDFGRST")) /* specifiers for registers=>no size 2b specified */	2387	if (strpbrk(str, "CDFGRST")) /* specifiers for registers=>no size 2b specified */
2388		2388
2389	must_do_size = 0;	2389	must_do_size = 0;
2390		2390
2391	while ((c = *str++) != 0) {	2391	while ((c = *str++) != 0) {
2392		2392
2393	if (c == '%') {	2393	if (c == '%') {
2394		2394
2395	c = *str++;	2395	c = *str++;
2396		2396
2397	if(*str=='y'){	2397	if(*str=='y'){
2398		2398
2399	qwordop=1;	2399	qwordop=1;
2400		2400
2401	str++;	2401	str++;
2402		2402
2403	}	2403	}
2404		2404
2405	percent(c,*str++);	2405	percent(c,*str++);
2406		2406
2407	}	2407	}
2408		2408
2409	else {	2409	else {
2410		2410
2411	if (c == ' ') uputchar('\t');	2411	if (c == ' ') uputchar('\t');
2412		2412
2413	else uputchar(c);	2413	else uputchar(c);
2414		2414
2415	}	2415	}
2416		2416
2417	}	2417	}
2418		2418
2419	}	2419	}
2420		2420
2421		2421
2422		2422
2423	void unassemble(unsigned long ofs)	2423	void unassemble(unsigned long ofs)
2424		2424
2425	{	2425	{
2426		2426
2427	char *str;	2427	char *str;
2428		2428
2429	int c;	2429	int c;
2430		2430
2431	fprintf(hout,seg_size==16?"%04X ":"%08lX ",ofs);	2431	fprintf(hout,seg_size==16?"%04X ":"%08lX ",ofs);
2432		2432
2433	prefix = 0;	2433	prefix = 0;
2434		2434
2435	modrmv = sibv = 0xFFFFFFFF; /* set modrm and sib flags */	2435	modrmv = sibv = 0xFFFFFFFF; /* set modrm and sib flags */
2436		2436
2437	opsize = addrsize = seg_size;	2437	opsize = addrsize = seg_size;
2438		2438
2439	col = 0;	2439	col = 0;
2440		2440
2441	ubufp = ubuf;	2441	ubufp = ubuf;
2442		2442
2443	done_space = 0;	2443	done_space = 0;
2444		2444
2445	c = getbyte();	2445	c = getbyte();
2446		2446
2447	if(c==0x9B){	2447	if(c==0x9B){
2448		2448
2449	switch((short )&output[outptr]){	2449	switch((short )&output[outptr]){
2450		2450
2451	case 0xE0DB:	2451	case 0xE0DB:
2452		2452
2453	case 0xE1DB:	2453	case 0xE1DB:
2454		2454
2455	case 0xE2DB:	2455	case 0xE2DB:
2456		2456
2457	case 0xE3DB:	2457	case 0xE3DB:
2458		2458
2459	case 0xE4DB:	2459	case 0xE4DB:
2460		2460
2461	getbyte();	2461	getbyte();
2462		2462
2463	c=getbyte();	2463	c=getbyte();
2464		2464
2465	switch(c){	2465	switch(c){
2466		2466
2467	case 0xE0:	2467	case 0xE0:
2468		2468
2469	ua_str("feni");	2469	ua_str("feni");
2470		2470
2471	break;	2471	break;
2472		2472
2473	case 0xE1:	2473	case 0xE1:
2474		2474
2475	ua_str("fdisi");	2475	ua_str("fdisi");
2476		2476
2477	break;	2477	break;
2478		2478
2479	case 0xE2:	2479	case 0xE2:
2480		2480
2481	ua_str("fclex");	2481	ua_str("fclex");
2482		2482
2483	break;	2483	break;
2484		2484
2485	case 0xE3:	2485	case 0xE3:
2486		2486
2487	ua_str("finit");	2487	ua_str("finit");
2488		2488
2489	break;	2489	break;
2490		2490
2491	case 0xE4:	2491	case 0xE4:
2492		2492
2493	ua_str("fsetpm");	2493	ua_str("fsetpm");
2494		2494
2495	break;	2495	break;
2496		2496
2497	}	2497	}
2498		2498
2499	goto endp;	2499	goto endp;
2500		2500
2501	}	2501	}
2502		2502
2503	}	2503	}
2504		2504
2505	else if(c==0x98){	2505	else if(c==0x98){
2506		2506
2507	if(am32){	2507	if(am32){
2508		2508
2509	ua_str("cwde");	2509	ua_str("cwde");
2510		2510
2511	goto endp;	2511	goto endp;
2512		2512
2513	}	2513	}
2514		2514
2515	}	2515	}
2516		2516
2517	else if(c==0x99){	2517	else if(c==0x99){
2518		2518
2519	if(am32){	2519	if(am32){
2520		2520
2521	ua_str("cdq");	2521	ua_str("cdq");
2522		2522
2523	goto endp;	2523	goto endp;
2524		2524
2525	}	2525	}
2526		2526
2527	}	2527	}
2528		2528
2529	else if(c==0x66&&am32==0){	2529	else if(c==0x66&&am32==0){
2530		2530
2531	if(output[outptr]==0x98){	2531	if(output[outptr]==0x98){
2532		2532
2533	ua_str("cwde");	2533	ua_str("cwde");
2534		2534
2535	getbyte();	2535	getbyte();
2536		2536
2537	goto endp;	2537	goto endp;
2538		2538
2539	}	2539	}
2540		2540
2541	if(output[outptr]==0x99){	2541	if(output[outptr]==0x99){
2542		2542
2543	ua_str("cdq");	2543	ua_str("cdq");
2544		2544
2545	getbyte();	2545	getbyte();
2546		2546
2547	goto endp;	2547	goto endp;
2548		2548
2549	}	2549	}
2550		2550
2551	}	2551	}
2552		2552
2553	else if(c==0xF3&&output[outptr]==0x90){	2553	else if(c==0xF3&&output[outptr]==0x90){
2554		2554
2555	ua_str("pause");	2555	ua_str("pause");
2556		2556
2557	getbyte();	2557	getbyte();
2558		2558
2559	goto endp;	2559	goto endp;
2560		2560
2561	}	2561	}
2562		2562
2563	if(output[outptr]==0x0f){	2563	if(output[outptr]==0x0f){
2564		2564
2565	int c2=output[outptr+1];	2565	int c2=output[outptr+1];
2566		2566
2567	switch(c){	2567	switch(c){
2568		2568
2569	case 0x66:	2569	case 0x66:
2570		2570
2571	if(second_660f[c2]){	2571	if(second_660f[c2]){
2572		2572
2573	getbyte();	2573	getbyte();
2574		2574
2575	ua_str(second_660f[getbyte()]);	2575	ua_str(second_660f[getbyte()]);
2576		2576
2577	goto endp;	2577	goto endp;
2578		2578
2579	}	2579	}
2580		2580
2581	break;	2581	break;
2582		2582
2583	case 0xf2:	2583	case 0xf2:
2584		2584
2585	if(second_f20f[c2]){	2585	if(second_f20f[c2]){
2586		2586
2587	getbyte();	2587	getbyte();
2588		2588
2589	ua_str(second_f20f[getbyte()]);	2589	ua_str(second_f20f[getbyte()]);
2590		2590
2591	goto endp;	2591	goto endp;
2592		2592
2593	}	2593	}
2594		2594
2595	break;	2595	break;
2596		2596
2597	case 0xf3:	2597	case 0xf3:
2598		2598
2599	if(second_f30f[c2]){	2599	if(second_f30f[c2]){
2600		2600
2601	getbyte();	2601	getbyte();
2602		2602
2603	ua_str(second_f30f[getbyte()]);	2603	ua_str(second_f30f[getbyte()]);
2604		2604
2605	goto endp;	2605	goto endp;
2606		2606
2607	}	2607	}
2608		2608
2609	break;	2609	break;
2610		2610
2611	}	2611	}
2612		2612
2613	}	2613	}
2614		2614
2615	wordop = c & 1;	2615	wordop = c & 1;
2616		2616
2617	qwordop=0;	2617	qwordop=0;
2618		2618
2619	must_do_size = 1;	2619	must_do_size = 1;
2620		2620
2621	if ((str = opmap1[c])==NULL) { /* invalid instruction? */	2621	if ((str = opmap1[c])==NULL) { /* invalid instruction? */
2622		2622
2623	uputchar('d'); /* then output byte defines */	2623	uputchar('d'); /* then output byte defines */
2624		2624
2625	uputchar('b');	2625	uputchar('b');
2626		2626
2627	uputchar('\t');	2627	uputchar('\t');
2628		2628
2629	uprintf("%02Xh",c);	2629	uprintf("%02Xh",c);
2630		2630
2631	}	2631	}
2632		2632
2633	else ua_str(str); /* valid instruction */	2633	else ua_str(str); /* valid instruction */
2634		2634
2635	endp:	2635	endp:
2636		2636
2637	fprintf(hout,"%*s", 25-col, " ");	2637	fprintf(hout,"%*s", 25-col, " ");
2638		2638
2639	fprintf(hout,"%s\n", ubuf);	2639	fprintf(hout,"%s\n", ubuf);
2640		2640
2641	}	2641	}
2642		2642
2643		2643
2644		2644
2645	#define MAXSTR 12	2645	#define MAXSTR 12
2646		2646
2647		2647
2648		2648
2649	void undata(unsigned ofs,unsigned long len,unsigned int type)	2649	void undata(unsigned ofs,unsigned long len,unsigned int type)
2650		2650
2651	{	2651	{
2652		2652
2653	unsigned int sizet,c,i,j;	2653	unsigned int sizet,c,i,j;
2654		2654
2655	unsigned long total,d;	2655	unsigned long total,d;
2656		2656
2657	unsigned char data[MAXSTR];	2657	unsigned char data[MAXSTR];
2658		2658
2659	if(type==3)sizet=1;	2659	if(type==3)sizet=1;
2660		2660
2661	else sizet=type;	2661	else sizet=type;
2662		2662
2663	for(total=0;total	2663	for(total=0;total
2664		2664
2665	col=0;	2665	col=0;
2666		2666
2667	ubufp=ubuf;	2667	ubufp=ubuf;
2668		2668
2669	fprintf(hout,seg_size==16?"%04X ":"%08lX ",ofs);	2669	fprintf(hout,seg_size==16?"%04X ":"%08lX ",ofs);
2670		2670
2671	if((total+sizet)>len){	2671	if((total+sizet)>len){
2672		2672
2673	type=sizet=1;	2673	type=sizet=1;
2674		2674
2675	}	2675	}
2676		2676
2677	for(i=0;i	2677	for(i=0;i
2678		2678
2679	switch(sizet){	2679	switch(sizet){
2680		2680
2681	case 1:	2681	case 1:
2682		2682
2683	data[i++]=getbyte();	2683	data[i++]=getbyte();
2684		2684
2685	break;	2685	break;
2686		2686
2687	case 2:	2687	case 2:
2688		2688
2689	data[i++]=getbyte();	2689	data[i++]=getbyte();
2690		2690
2691	data[i++]=getbyte();	2691	data[i++]=getbyte();
2692		2692
2693	total++;	2693	total++;
2694		2694
2695	break;	2695	break;
2696		2696
2697	case 4:	2697	case 4:
2698		2698
2699	data[i++]=getbyte();	2699	data[i++]=getbyte();
2700		2700
2701	data[i++]=getbyte();	2701	data[i++]=getbyte();
2702		2702
2703	data[i++]=getbyte();	2703	data[i++]=getbyte();
2704		2704
2705	data[i++]=getbyte();	2705	data[i++]=getbyte();
2706		2706
2707	total+=3;	2707	total+=3;
2708		2708
2709	break;	2709	break;
2710		2710
2711	case 8:	2711	case 8:
2712		2712
2713	data[i++]=getbyte();	2713	data[i++]=getbyte();
2714		2714
2715	data[i++]=getbyte();	2715	data[i++]=getbyte();
2716		2716
2717	data[i++]=getbyte();	2717	data[i++]=getbyte();
2718		2718
2719	data[i++]=getbyte();	2719	data[i++]=getbyte();
2720		2720
2721	data[i++]=getbyte();	2721	data[i++]=getbyte();
2722		2722
2723	data[i++]=getbyte();	2723	data[i++]=getbyte();
2724		2724
2725	data[i++]=getbyte();	2725	data[i++]=getbyte();
2726		2726
2727	data[i++]=getbyte();	2727	data[i++]=getbyte();
2728		2728
2729	total+=7;	2729	total+=7;
2730		2730
2731	break;	2731	break;
2732		2732
2733	}	2733	}
2734		2734
2735	total++;	2735	total++;
2736		2736
2737	if((total+sizet)>len)break;	2737	if((total+sizet)>len)break;
2738		2738
2739	if(sizet==8)break;	2739	if(sizet==8)break;
2740		2740
2741	}	2741	}
2742		2742
2743	uputchar(sizet==8?'q':'d');	2743	uputchar(sizet==8?'q':'d');
2744		2744
2745	switch(sizet){	2745	switch(sizet){
2746		2746
2747	case 1:	2747	case 1:
2748		2748
2749	uputchar('b');	2749	uputchar('b');
2750		2750
2751	break;	2751	break;
2752		2752
2753	case 2:	2753	case 2:
2754		2754
2755	case 8:	2755	case 8:
2756		2756
2757	uputchar('w');	2757	uputchar('w');
2758		2758
2759	break;	2759	break;
2760		2760
2761	case 4:	2761	case 4:
2762		2762
2763	uputchar('d');	2763	uputchar('d');
2764		2764
2765	break;	2765	break;
2766		2766
2767	}	2767	}
2768		2768
2769	done_space=0;	2769	done_space=0;
2770		2770
2771	uputchar('\t');	2771	uputchar('\t');
2772		2772
2773	switch(type){	2773	switch(type){
2774		2774
2775	case 1:	2775	case 1:
2776		2776
2777	for(j=0;j	2777	for(j=0;j
2778		2778
2779	printbyte(data[j]);	2779	printbyte(data[j]);
2780		2780
2781	if((j+1)!=i)uputchar(',');	2781	if((j+1)!=i)uputchar(',');
2782		2782
2783	}	2783	}
2784		2784
2785	break;	2785	break;
2786		2786
2787	case 2:	2787	case 2:
2788		2788
2789	for(j=0;j	2789	for(j=0;j
2790		2790
2791	d=data[j++];	2791	d=data[j++];
2792		2792
2793	d+=data[j++]<<8;	2793	d+=data[j++]<<8;
2794		2794
2795	printword((unsigned short)d);	2795	printword((unsigned short)d);
2796		2796
2797	// uprintf("%05Xh",(unsigned int)d);	2797	// uprintf("%05Xh",(unsigned int)d);
2798		2798
2799	if(j!=i)uputchar(',');	2799	if(j!=i)uputchar(',');
2800		2800
2801	}	2801	}
2802		2802
2803	break;	2803	break;
2804		2804
2805	case 3:	2805	case 3:
2806		2806
2807	c=0;	2807	c=0;
2808		2808
2809	for(j=0;j	2809	for(j=0;j
2810		2810
2811	if(data[j]>=0x20){	2811	if(data[j]>=0x20){
2812		2812
2813	if(c==0){	2813	if(c==0){
2814		2814
2815	c++;	2815	c++;
2816		2816
2817	if(j!=0)uputchar(',');	2817	if(j!=0)uputchar(',');
2818		2818
2819	uputchar(0x27);	2819	uputchar(0x27);
2820		2820
2821	}	2821	}
2822		2822
2823	uputchar(data[j]);	2823	uputchar(data[j]);
2824		2824
2825	}	2825	}
2826		2826
2827	else{	2827	else{
2828		2828
2829	if(c!=0){	2829	if(c!=0){
2830		2830
2831	c=0;	2831	c=0;
2832		2832
2833	uputchar(0x27);	2833	uputchar(0x27);
2834		2834
2835	}	2835	}
2836		2836
2837	if(j!=0)uputchar(',');	2837	if(j!=0)uputchar(',');
2838		2838
2839	printbyte(data[j]);	2839	printbyte(data[j]);
2840		2840
2841	}	2841	}
2842		2842
2843	}	2843	}
2844		2844
2845	if(c)uputchar(0x27);	2845	if(c)uputchar(0x27);
2846		2846
2847	break;	2847	break;
2848		2848
2849	case 4:	2849	case 4:
2850		2850
2851	for(j=0;j	2851	for(j=0;j
2852		2852
2853	d=data[j++];	2853	d=data[j++];
2854		2854
2855	d+=data[j++]<<8;	2855	d+=data[j++]<<8;
2856		2856
2857	d+=data[j++]<<16;	2857	d+=data[j++]<<16;
2858		2858
2859	d+=data[j++]<<24;	2859	d+=data[j++]<<24;
2860		2860
2861	printdword((unsigned int)d);	2861	printdword((unsigned int)d);
2862		2862
2863	// uprintf("%09lXh",(unsigned int)d);	2863	// uprintf("%09lXh",(unsigned int)d);
2864		2864
2865	if(j!=i)uputchar(',');	2865	if(j!=i)uputchar(',');
2866		2866
2867	}	2867	}
2868		2868
2869	break;	2869	break;
2870		2870
2871	case 8:	2871	case 8:
2872		2872
2873	for(j=0;j	2873	for(j=0;j
2874		2874
2875	j+=4;	2875	j+=4;
2876		2876
2877	d=data[j++];	2877	d=data[j++];
2878		2878
2879	d+=data[j++]<<8;	2879	d+=data[j++]<<8;
2880		2880
2881	d+=data[j++]<<16;	2881	d+=data[j++]<<16;
2882		2882
2883	d+=data[j++]<<24;	2883	d+=data[j++]<<24;
2884		2884
2885	if(d)uprintf("%lX",d);	2885	if(d)uprintf("%lX",d);
2886		2886
2887	unsigned long d2;	2887	unsigned long d2;
2888		2888
2889	d2=d;	2889	d2=d;
2890		2890
2891	j-=8;	2891	j-=8;
2892		2892
2893	d=data[j++];	2893	d=data[j++];
2894		2894
2895	d+=data[j++]<<8;	2895	d+=data[j++]<<8;
2896		2896
2897	d+=data[j++]<<16;	2897	d+=data[j++]<<16;
2898		2898
2899	d+=data[j++]<<24;	2899	d+=data[j++]<<24;
2900		2900
2901	if(d2==0)	2901	if(d2==0)
2902		2902
2903	uprintf("%lXh",(char)d);	2903	uprintf("%lXh",(char)d);
2904		2904
2905	else	2905	else
2906		2906
2907	uprintf("%08lXh",(char)d);	2907	uprintf("%08lXh",(char)d);
2908		2908
2909	j+=4;	2909	j+=4;
2910		2910
2911	if(j!=i)uputchar(',');	2911	if(j!=i)uputchar(',');
2912		2912
2913	}	2913	}
2914		2914
2915	break;	2915	break;
2916		2916
2917	}	2917	}
2918		2918
2919	fprintf(hout,"%*s",25-col," ");	2919	fprintf(hout,"%*s",25-col," ");
2920		2920
2921	fprintf(hout,"%s\n", ubuf);	2921	fprintf(hout,"%s\n", ubuf);
2922		2922
2923	ofs+=i;	2923	ofs+=i;
2924		2924
2925	}	2925	}
2926		2926
2927	}	2927	}
2928		2928
2929	>	2929	>
2930		2930
2931	>	2931	>
2932		2932
2933	>	2933	>
2934		2934
2935	>	2935	>
2936		2936
2937	>	2937	>
2938		2938
2939	>	2939	>
2940		2940
2941	>	2941	>
2942		2942
2943	>	2943	>
2944		2944
2945	>	2945	>
2946		2946
2947	>	2947	>
2948		2948
2949	>	2949	>
2950		2950
2951	>	2951	>
2952		2952
2953	>	2953	>
2954		2954
2955	>	2955	>
2956		2956
2957	>	2957	>
2958		2958
2959	>	2959	>
2960		2960
2961	>	2961	>
2962		2962
2963	>	2963	>
2964		2964
2965	>	2965	>
2966		2966
2967	>	2967	>
2968		2968
2969	>	2969	>
2970		2970
2971	>	2971	>
2972		2972
2973	>	2973	>
2974		2974
2975	>	2975	>
2976		2976
2977	>	2977	>
2978		2978
2979	>	2979	>
2980		2980
2981	>	2981	>
2982		2982
2983	>	2983	>
2984		2984
2985	>	2985	>
2986		2986
2987	>	2987	>
2988		2988
2989	>	2989	>
2990		2990
2991	>	2991	>
2992		2992
2993	>	2993	>
2994		2994
2995	>	2995	>
2996		2996
2997	>	2997	>

Subversion Repositories Kolibri OS

(root)/programs/develop/cmm/disasm.cpp – Rev 6446 → 7626