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

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

Subversion Repositories Kolibri OS

(root)/programs/develop/cmm/disasm.cpp – Rev 7700