17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5dc0093f4Seschrock  * Common Development and Distribution License (the "License").
6dc0093f4Seschrock  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
217c478bd9Sstevel@tonic-gate /*
22dc0093f4Seschrock  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
237c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate  */
257c478bd9Sstevel@tonic-gate 
267c478bd9Sstevel@tonic-gate /*	Copyright (c) 1988 AT&T	*/
277c478bd9Sstevel@tonic-gate /*	  All Rights Reserved  	*/
287c478bd9Sstevel@tonic-gate 
297c478bd9Sstevel@tonic-gate 
307c478bd9Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
317c478bd9Sstevel@tonic-gate 
327c478bd9Sstevel@tonic-gate #include	"dis_tables.h"
337c478bd9Sstevel@tonic-gate 
347c478bd9Sstevel@tonic-gate /* BEGIN CSTYLED */
357c478bd9Sstevel@tonic-gate 
367c478bd9Sstevel@tonic-gate /*
377c478bd9Sstevel@tonic-gate  * Disassembly begins in dis_distable, which is equivalent to the One-byte
387c478bd9Sstevel@tonic-gate  * Opcode Map in the Intel IA32 ISA Reference (page A-6 in my copy).  The
397c478bd9Sstevel@tonic-gate  * decoding loops then traverse out through the other tables as necessary to
407c478bd9Sstevel@tonic-gate  * decode a given instruction.
417c478bd9Sstevel@tonic-gate  *
427c478bd9Sstevel@tonic-gate  * The behavior of this file can be controlled by one of the following flags:
437c478bd9Sstevel@tonic-gate  *
447c478bd9Sstevel@tonic-gate  * 	DIS_TEXT	Include text for disassembly
457c478bd9Sstevel@tonic-gate  * 	DIS_MEM		Include memory-size calculations
467c478bd9Sstevel@tonic-gate  *
477c478bd9Sstevel@tonic-gate  * Either or both of these can be defined.
487c478bd9Sstevel@tonic-gate  *
497c478bd9Sstevel@tonic-gate  * This file is not, and will never be, cstyled.  If anything, the tables should
507c478bd9Sstevel@tonic-gate  * be taken out another tab stop or two so nothing overlaps.
517c478bd9Sstevel@tonic-gate  */
527c478bd9Sstevel@tonic-gate 
537c478bd9Sstevel@tonic-gate /*
547c478bd9Sstevel@tonic-gate  * These functions must be provided for the consumer to do disassembly.
557c478bd9Sstevel@tonic-gate  */
567c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
577c478bd9Sstevel@tonic-gate extern char *strncpy(char *, const char *, size_t);
587c478bd9Sstevel@tonic-gate extern size_t strlen(const char *);
597c478bd9Sstevel@tonic-gate extern int strcmp(const char *, const char *);
607c478bd9Sstevel@tonic-gate extern int strncmp(const char *, const char *, size_t);
617c478bd9Sstevel@tonic-gate extern size_t strlcat(char *, const char *, size_t);
627c478bd9Sstevel@tonic-gate #endif
637c478bd9Sstevel@tonic-gate 
647c478bd9Sstevel@tonic-gate 
657c478bd9Sstevel@tonic-gate #define		TERM 	0	/* used to indicate that the 'indirect' */
667c478bd9Sstevel@tonic-gate 				/* field terminates - no pointer.	*/
677c478bd9Sstevel@tonic-gate 
687c478bd9Sstevel@tonic-gate /* Used to decode instructions. */
697c478bd9Sstevel@tonic-gate typedef struct	instable {
707c478bd9Sstevel@tonic-gate 	struct instable	*it_indirect;	/* for decode op codes */
717c478bd9Sstevel@tonic-gate 	uchar_t		it_adrmode;
727c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
737c478bd9Sstevel@tonic-gate 	char		it_name[NCPS];
74*d267098bSdmick 	uint_t		it_suffix:1;		/* mnem + "w", "l", or "d" */
757c478bd9Sstevel@tonic-gate #endif
767c478bd9Sstevel@tonic-gate #ifdef DIS_MEM
777c478bd9Sstevel@tonic-gate 	uint_t		it_size:16;
787c478bd9Sstevel@tonic-gate #endif
797c478bd9Sstevel@tonic-gate 	uint_t		it_invalid64:1;		/* opcode invalid in amd64 */
807c478bd9Sstevel@tonic-gate 	uint_t		it_always64:1;		/* 64 bit when in 64 bit mode */
817c478bd9Sstevel@tonic-gate 	uint_t		it_invalid32:1;		/* invalid in IA32 */
827c478bd9Sstevel@tonic-gate 	uint_t		it_stackop:1;		/* push/pop stack operation */
837c478bd9Sstevel@tonic-gate } instable_t;
847c478bd9Sstevel@tonic-gate 
857c478bd9Sstevel@tonic-gate /*
867c478bd9Sstevel@tonic-gate  * Instruction formats.
877c478bd9Sstevel@tonic-gate  */
887c478bd9Sstevel@tonic-gate enum {
897c478bd9Sstevel@tonic-gate 	UNKNOWN,
907c478bd9Sstevel@tonic-gate 	MRw,
917c478bd9Sstevel@tonic-gate 	IMlw,
927c478bd9Sstevel@tonic-gate 	IMw,
937c478bd9Sstevel@tonic-gate 	IR,
947c478bd9Sstevel@tonic-gate 	OA,
957c478bd9Sstevel@tonic-gate 	AO,
967c478bd9Sstevel@tonic-gate 	MS,
977c478bd9Sstevel@tonic-gate 	SM,
987c478bd9Sstevel@tonic-gate 	Mv,
997c478bd9Sstevel@tonic-gate 	Mw,
1007c478bd9Sstevel@tonic-gate 	M,		/* register or memory */
1017c478bd9Sstevel@tonic-gate 	Mb,		/* register or memory, always byte sized */
1027c478bd9Sstevel@tonic-gate 	MO,		/* memory only (no registers) */
1037c478bd9Sstevel@tonic-gate 	PREF,
1047c478bd9Sstevel@tonic-gate 	SWAPGS,
1057c478bd9Sstevel@tonic-gate 	R,
1067c478bd9Sstevel@tonic-gate 	RA,
1077c478bd9Sstevel@tonic-gate 	SEG,
1087c478bd9Sstevel@tonic-gate 	MR,
1097c478bd9Sstevel@tonic-gate 	RM,
1107c478bd9Sstevel@tonic-gate 	IA,
1117c478bd9Sstevel@tonic-gate 	MA,
1127c478bd9Sstevel@tonic-gate 	SD,
1137c478bd9Sstevel@tonic-gate 	AD,
1147c478bd9Sstevel@tonic-gate 	SA,
1157c478bd9Sstevel@tonic-gate 	D,
1167c478bd9Sstevel@tonic-gate 	INM,
1177c478bd9Sstevel@tonic-gate 	SO,
1187c478bd9Sstevel@tonic-gate 	BD,
1197c478bd9Sstevel@tonic-gate 	I,
1207c478bd9Sstevel@tonic-gate 	P,
1217c478bd9Sstevel@tonic-gate 	V,
1227c478bd9Sstevel@tonic-gate 	DSHIFT,		/* for double shift that has an 8-bit immediate */
1237c478bd9Sstevel@tonic-gate 	U,
1247c478bd9Sstevel@tonic-gate 	OVERRIDE,
1257c478bd9Sstevel@tonic-gate 	NORM,		/* instructions w/o ModR/M byte, no memory access */
1267c478bd9Sstevel@tonic-gate 	IMPLMEM,	/* instructions w/o ModR/M byte, implicit mem access */
1277c478bd9Sstevel@tonic-gate 	O,		/* for call	*/
1287c478bd9Sstevel@tonic-gate 	JTAB,		/* jump table 	*/
1297c478bd9Sstevel@tonic-gate 	IMUL,		/* for 186 iimul instr  */
1307c478bd9Sstevel@tonic-gate 	CBW,		/* so data16 can be evaluated for cbw and variants */
1317c478bd9Sstevel@tonic-gate 	MvI,		/* for 186 logicals */
1327c478bd9Sstevel@tonic-gate 	ENTER,		/* for 186 enter instr  */
1337c478bd9Sstevel@tonic-gate 	RMw,		/* for 286 arpl instr */
1347c478bd9Sstevel@tonic-gate 	Ib,		/* for push immediate byte */
1357c478bd9Sstevel@tonic-gate 	F,		/* for 287 instructions */
1367c478bd9Sstevel@tonic-gate 	FF,		/* for 287 instructions */
1377c478bd9Sstevel@tonic-gate 	FFC,		/* for 287 instructions */
1387c478bd9Sstevel@tonic-gate 	DM,		/* 16-bit data */
1397c478bd9Sstevel@tonic-gate 	AM,		/* 16-bit addr */
1407c478bd9Sstevel@tonic-gate 	LSEG,		/* for 3-bit seg reg encoding */
1417c478bd9Sstevel@tonic-gate 	MIb,		/* for 386 logicals */
1427c478bd9Sstevel@tonic-gate 	SREG,		/* for 386 special registers */
1437c478bd9Sstevel@tonic-gate 	PREFIX,		/* a REP instruction prefix */
1447c478bd9Sstevel@tonic-gate 	LOCK,		/* a LOCK instruction prefix */
1457c478bd9Sstevel@tonic-gate 	INT3,		/* The int 3 instruction, which has a fake operand */
1467c478bd9Sstevel@tonic-gate 	INTx,		/* The normal int instruction, with explicit int num */
1477c478bd9Sstevel@tonic-gate 	DSHIFTcl,	/* for double shift that implicitly uses %cl */
1487c478bd9Sstevel@tonic-gate 	CWD,		/* so data16 can be evaluated for cwd and variants */
1497c478bd9Sstevel@tonic-gate 	RET,		/* single immediate 16-bit operand */
1507c478bd9Sstevel@tonic-gate 	MOVZ,		/* for movs and movz, with different size operands */
1517c478bd9Sstevel@tonic-gate 	XADDB,		/* for xaddb */
1527c478bd9Sstevel@tonic-gate 	MOVSXZ,		/* AMD64 mov sign extend 32 to 64 bit instruction */
1537c478bd9Sstevel@tonic-gate 
1547c478bd9Sstevel@tonic-gate /*
1557c478bd9Sstevel@tonic-gate  * MMX/SIMD addressing modes.
1567c478bd9Sstevel@tonic-gate  */
1577c478bd9Sstevel@tonic-gate 
1587c478bd9Sstevel@tonic-gate 	MMO,		/* Prefixable MMX/SIMD-Int	mm/mem	-> mm */
1597c478bd9Sstevel@tonic-gate 	MMOIMPL,	/* Prefixable MMX/SIMD-Int	mm	-> mm (mem) */
1607c478bd9Sstevel@tonic-gate 	MMO3P,		/* Prefixable MMX/SIMD-Int	mm	-> r32,imm8 */
1617c478bd9Sstevel@tonic-gate 	MMOM3,		/* Prefixable MMX/SIMD-Int	mm	-> r32 	*/
1627c478bd9Sstevel@tonic-gate 	MMOS,		/* Prefixable MMX/SIMD-Int	mm	-> mm/mem */
1637c478bd9Sstevel@tonic-gate 	MMOMS,		/* Prefixable MMX/SIMD-Int	mm	-> mem */
1647c478bd9Sstevel@tonic-gate 	MMOPM,		/* MMX/SIMD-Int			mm/mem	-> mm,imm8 */
1657c478bd9Sstevel@tonic-gate 	MMOPRM,		/* Prefixable MMX/SIMD-Int	r32/mem	-> mm,imm8 */
1667c478bd9Sstevel@tonic-gate 	MMOSH,		/* Prefixable MMX		mm,imm8	*/
1677c478bd9Sstevel@tonic-gate 	MM,		/* MMX/SIMD-Int			mm/mem	-> mm	*/
1687c478bd9Sstevel@tonic-gate 	MMS,		/* MMX/SIMD-Int			mm	-> mm/mem */
1697c478bd9Sstevel@tonic-gate 	MMSH,		/* MMX				mm,imm8 */
1707c478bd9Sstevel@tonic-gate 	XMMO,		/* Prefixable SIMD		xmm/mem	-> xmm */
1717c478bd9Sstevel@tonic-gate 	XMMOS,		/* Prefixable SIMD		xmm	-> xmm/mem */
1727c478bd9Sstevel@tonic-gate 	XMMOPM,		/* Prefixable SIMD		xmm/mem	w/to xmm,imm8 */
1737c478bd9Sstevel@tonic-gate 	XMMOMX,		/* Prefixable SIMD		mm/mem	-> xmm */
1747c478bd9Sstevel@tonic-gate 	XMMOX3,		/* Prefixable SIMD		xmm	-> r32 */
1757c478bd9Sstevel@tonic-gate 	XMMOXMM,	/* Prefixable SIMD		xmm/mem	-> mm	*/
1767c478bd9Sstevel@tonic-gate 	XMMOM,		/* Prefixable SIMD		xmm	-> mem */
1777c478bd9Sstevel@tonic-gate 	XMMOMS,		/* Prefixable SIMD		mem	-> xmm */
1787c478bd9Sstevel@tonic-gate 	XMM,		/* SIMD 			xmm/mem	-> xmm */
1797c478bd9Sstevel@tonic-gate 	XMMXIMPL,	/* SIMD				xmm	-> xmm (mem) */
1807c478bd9Sstevel@tonic-gate 	XMM3P,		/* SIMD				xmm	-> r32,imm8 */
1817c478bd9Sstevel@tonic-gate 	XMMP,		/* SIMD 			xmm/mem w/to xmm,imm8 */
1827c478bd9Sstevel@tonic-gate 	XMMPRM,		/* SIMD 			r32/mem -> xmm,imm8 */
1837c478bd9Sstevel@tonic-gate 	XMMS,		/* SIMD				xmm	-> xmm/mem */
1847c478bd9Sstevel@tonic-gate 	XMMM,		/* SIMD 			mem	-> xmm */
1857c478bd9Sstevel@tonic-gate 	XMMMS,		/* SIMD				xmm	-> mem */
1867c478bd9Sstevel@tonic-gate 	XMM3MX,		/* SIMD 			r32/mem -> xmm */
1877c478bd9Sstevel@tonic-gate 	XMM3MXS,	/* SIMD 			xmm	-> r32/mem */
1887c478bd9Sstevel@tonic-gate 	XMMSH,		/* SIMD 			xmm,imm8 */
1897c478bd9Sstevel@tonic-gate 	XMMXM3,		/* SIMD 			xmm/mem -> r32 */
1907c478bd9Sstevel@tonic-gate 	XMMX3,		/* SIMD 			xmm	-> r32 */
1917c478bd9Sstevel@tonic-gate 	XMMXMM,		/* SIMD 			xmm/mem	-> mm */
1927c478bd9Sstevel@tonic-gate 	XMMMX,		/* SIMD 			mm	-> xmm */
1937c478bd9Sstevel@tonic-gate 	XMMXM,		/* SIMD 			xmm	-> mm */
1947c478bd9Sstevel@tonic-gate 	XMMFENCE,	/* SIMD lfence or mfence */
1957c478bd9Sstevel@tonic-gate 	XMMSFNC		/* SIMD sfence (none or mem) */
1967c478bd9Sstevel@tonic-gate };
1977c478bd9Sstevel@tonic-gate 
1987c478bd9Sstevel@tonic-gate #define	FILL	0x90	/* Fill byte used for alignment (nop)	*/
1997c478bd9Sstevel@tonic-gate 
2007c478bd9Sstevel@tonic-gate /*
2017c478bd9Sstevel@tonic-gate ** Register numbers for the i386
2027c478bd9Sstevel@tonic-gate */
2037c478bd9Sstevel@tonic-gate #define	EAX_REGNO 0
2047c478bd9Sstevel@tonic-gate #define	ECX_REGNO 1
2057c478bd9Sstevel@tonic-gate #define	EDX_REGNO 2
2067c478bd9Sstevel@tonic-gate #define	EBX_REGNO 3
2077c478bd9Sstevel@tonic-gate #define	ESP_REGNO 4
2087c478bd9Sstevel@tonic-gate #define	EBP_REGNO 5
2097c478bd9Sstevel@tonic-gate #define	ESI_REGNO 6
2107c478bd9Sstevel@tonic-gate #define	EDI_REGNO 7
2117c478bd9Sstevel@tonic-gate 
2127c478bd9Sstevel@tonic-gate /*
2137c478bd9Sstevel@tonic-gate  * modes for immediate values
2147c478bd9Sstevel@tonic-gate  */
2157c478bd9Sstevel@tonic-gate #define	MODE_NONE	0
2167c478bd9Sstevel@tonic-gate #define	MODE_IPREL	1	/* signed IP relative value */
2177c478bd9Sstevel@tonic-gate #define	MODE_SIGNED	2	/* sign extended immediate */
2187c478bd9Sstevel@tonic-gate #define	MODE_IMPLIED	3	/* constant value implied from opcode */
2197c478bd9Sstevel@tonic-gate #define	MODE_OFFSET	4	/* offset part of an address */
220*d267098bSdmick #define	MODE_RIPREL	5	/* like IPREL, but from %rip (amd64) */
2217c478bd9Sstevel@tonic-gate 
2227c478bd9Sstevel@tonic-gate /*
2237c478bd9Sstevel@tonic-gate  * The letters used in these macros are:
2247c478bd9Sstevel@tonic-gate  *   IND - indirect to another to another table
2257c478bd9Sstevel@tonic-gate  *   "T" - means to Terminate indirections (this is the final opcode)
2267c478bd9Sstevel@tonic-gate  *   "S" - means "operand length suffix required"
2277c478bd9Sstevel@tonic-gate  *   "NS" - means "no suffix" which is the operand length suffix of the opcode
2287c478bd9Sstevel@tonic-gate  *   "Z" - means instruction size arg required
2297c478bd9Sstevel@tonic-gate  *   "u" - means the opcode is invalid in IA32 but valid in amd64
2307c478bd9Sstevel@tonic-gate  *   "x" - means the opcode is invalid in amd64, but not IA32
2317c478bd9Sstevel@tonic-gate  *   "y" - means the operand size is always 64 bits in 64 bit mode
2327c478bd9Sstevel@tonic-gate  *   "p" - means push/pop stack operation
2337c478bd9Sstevel@tonic-gate  */
2347c478bd9Sstevel@tonic-gate 
2357c478bd9Sstevel@tonic-gate #if defined(DIS_TEXT) && defined(DIS_MEM)
2367c478bd9Sstevel@tonic-gate #define	IND(table)		{(instable_t *)table, 0, "", 0, 0, 0, 0, 0, 0}
2377c478bd9Sstevel@tonic-gate #define	INDx(table)		{(instable_t *)table, 0, "", 0, 0, 1, 0, 0, 0}
2387c478bd9Sstevel@tonic-gate #define	TNS(name, amode)	{TERM, amode, name, 0, 0, 0, 0, 0, 0}
2397c478bd9Sstevel@tonic-gate #define	TNSu(name, amode)	{TERM, amode, name, 0, 0, 0, 0, 1, 0}
2407c478bd9Sstevel@tonic-gate #define	TNSx(name, amode)	{TERM, amode, name, 0, 0, 1, 0, 0, 0}
2417c478bd9Sstevel@tonic-gate #define	TNSy(name, amode)	{TERM, amode, name, 0, 0, 0, 1, 0, 0}
2427c478bd9Sstevel@tonic-gate #define	TNSyp(name, amode)	{TERM, amode, name, 0, 0, 0, 1, 0, 1}
2437c478bd9Sstevel@tonic-gate #define	TNSZ(name, amode, sz)	{TERM, amode, name, 0, sz, 0, 0, 0, 0}
2447c478bd9Sstevel@tonic-gate #define	TNSZy(name, amode, sz)	{TERM, amode, name, 0, sz, 0, 1, 0, 0}
2457c478bd9Sstevel@tonic-gate #define	TS(name, amode)		{TERM, amode, name, 1, 0, 0, 0, 0, 0}
2467c478bd9Sstevel@tonic-gate #define	TSx(name, amode)	{TERM, amode, name, 1, 0, 1, 0, 0, 0}
2477c478bd9Sstevel@tonic-gate #define	TSy(name, amode)	{TERM, amode, name, 1, 0, 0, 1, 0, 0}
2487c478bd9Sstevel@tonic-gate #define	TSp(name, amode)	{TERM, amode, name, 1, 0, 0, 0, 0, 1}
2497c478bd9Sstevel@tonic-gate #define	TSZ(name, amode, sz)	{TERM, amode, name, 1, sz, 0, 0, 0, 0}
2507c478bd9Sstevel@tonic-gate #define	TSZx(name, amode, sz)	{TERM, amode, name, 1, sz, 1, 0, 0, 0}
2517c478bd9Sstevel@tonic-gate #define	TSZy(name, amode, sz)	{TERM, amode, name, 1, sz, 0, 1, 0, 0}
2527c478bd9Sstevel@tonic-gate #define	INVALID			{TERM, UNKNOWN, "", 0, 0, 0, 0, 0}
2537c478bd9Sstevel@tonic-gate #elif defined(DIS_TEXT)
2547c478bd9Sstevel@tonic-gate #define	IND(table)		{(instable_t *)table, 0, "", 0, 0, 0, 0, 0}
2557c478bd9Sstevel@tonic-gate #define	INDx(table)		{(instable_t *)table, 0, "", 0, 1, 0, 0, 0}
2567c478bd9Sstevel@tonic-gate #define	TNS(name, amode)	{TERM, amode, name, 0, 0, 0, 0, 0}
2577c478bd9Sstevel@tonic-gate #define	TNSu(name, amode)	{TERM, amode, name, 0, 0, 0, 1, 0}
2587c478bd9Sstevel@tonic-gate #define	TNSx(name, amode)	{TERM, amode, name, 0, 1, 0, 0, 0}
2597c478bd9Sstevel@tonic-gate #define	TNSy(name, amode)	{TERM, amode, name, 0, 0, 1, 0, 0}
2607c478bd9Sstevel@tonic-gate #define	TNSyp(name, amode)	{TERM, amode, name, 0, 0, 1, 0, 1}
2617c478bd9Sstevel@tonic-gate #define	TNSZ(name, amode, sz)	{TERM, amode, name, 0, 0, 0, 0, 0}
2627c478bd9Sstevel@tonic-gate #define	TNSZy(name, amode, sz)	{TERM, amode, name, 0, 0, 1, 0, 0}
2637c478bd9Sstevel@tonic-gate #define	TS(name, amode)		{TERM, amode, name, 1, 0, 0, 0, 0}
2647c478bd9Sstevel@tonic-gate #define	TSx(name, amode)	{TERM, amode, name, 1, 1, 0, 0, 0}
2657c478bd9Sstevel@tonic-gate #define	TSy(name, amode)	{TERM, amode, name, 1, 0, 1, 0, 0}
2667c478bd9Sstevel@tonic-gate #define	TSp(name, amode)	{TERM, amode, name, 1, 0, 0, 0, 1}
2677c478bd9Sstevel@tonic-gate #define	TSZ(name, amode, sz)	{TERM, amode, name, 1, 0, 0, 0, 0}
2687c478bd9Sstevel@tonic-gate #define	TSZx(name, amode, sz)	{TERM, amode, name, 1, 1, 0, 0, 0}
2697c478bd9Sstevel@tonic-gate #define	TSZy(name, amode, sz)	{TERM, amode, name, 1, 0, 1, 0, 0}
2707c478bd9Sstevel@tonic-gate #define	INVALID			{TERM, UNKNOWN, "", 0, 0, 0, 0, 0}
2717c478bd9Sstevel@tonic-gate #elif defined(DIS_MEM)
2727c478bd9Sstevel@tonic-gate #define	IND(table)		{(instable_t *)table, 0, 0, 0, 0, 0, 0}
2737c478bd9Sstevel@tonic-gate #define	INDx(table)		{(instable_t *)table, 0, 0, 1, 0, 0, 0}
2747c478bd9Sstevel@tonic-gate #define	TNS(name, amode)	{TERM, amode,  0, 0, 0, 0, 0}
2757c478bd9Sstevel@tonic-gate #define	TNSu(name, amode)	{TERM, amode,  0, 0, 0, 1, 0}
2767c478bd9Sstevel@tonic-gate #define	TNSy(name, amode)	{TERM, amode,  0, 0, 1, 0, 0}
2777c478bd9Sstevel@tonic-gate #define	TNSyp(name, amode)	{TERM, amode,  0, 0, 1, 0, 1}
2787c478bd9Sstevel@tonic-gate #define	TNSx(name, amode)	{TERM, amode,  0, 1, 0, 0, 0}
2797c478bd9Sstevel@tonic-gate #define	TNSZ(name, amode, sz)	{TERM, amode, sz, 0, 0, 0, 0}
2807c478bd9Sstevel@tonic-gate #define	TNSZy(name, amode, sz)	{TERM, amode, sz, 0, 1, 0, 0}
2817c478bd9Sstevel@tonic-gate #define	TS(name, amode)		{TERM, amode,  0, 0, 0, 0, 0}
2827c478bd9Sstevel@tonic-gate #define	TSx(name, amode)	{TERM, amode,  0, 1, 0, 0, 0}
2837c478bd9Sstevel@tonic-gate #define	TSy(name, amode)	{TERM, amode,  0, 0, 1, 0, 0}
2847c478bd9Sstevel@tonic-gate #define	TSp(name, amode)	{TERM, amode,  0, 0, 0, 0, 1}
2857c478bd9Sstevel@tonic-gate #define	TSZ(name, amode, sz)	{TERM, amode, sz, 0, 0, 0, 0}
2867c478bd9Sstevel@tonic-gate #define	TSZx(name, amode, sz)	{TERM, amode, sz, 1, 0, 0, 0}
2877c478bd9Sstevel@tonic-gate #define	TSZy(name, amode, sz)	{TERM, amode, sz, 0, 1, 0, 0}
2887c478bd9Sstevel@tonic-gate #define	INVALID			{TERM, UNKNOWN, 0, 0, 0, 0, 0}
2897c478bd9Sstevel@tonic-gate #else
2907c478bd9Sstevel@tonic-gate #define	IND(table)		{(instable_t *)table, 0, 0, 0, 0, 0}
2917c478bd9Sstevel@tonic-gate #define	INDx(table)		{(instable_t *)table, 0, 1, 0, 0, 0}
2927c478bd9Sstevel@tonic-gate #define	TNS(name, amode)	{TERM, amode,  0, 0, 0, 0}
2937c478bd9Sstevel@tonic-gate #define	TNSu(name, amode)	{TERM, amode,  0, 0, 1, 0}
2947c478bd9Sstevel@tonic-gate #define	TNSy(name, amode)	{TERM, amode,  0, 1, 0, 0}
2957c478bd9Sstevel@tonic-gate #define	TNSyp(name, amode)	{TERM, amode,  0, 1, 0, 1}
2967c478bd9Sstevel@tonic-gate #define	TNSx(name, amode)	{TERM, amode,  1, 0, 0, 0}
2977c478bd9Sstevel@tonic-gate #define	TNSZ(name, amode, sz)	{TERM, amode,  0, 0, 0, 0}
2987c478bd9Sstevel@tonic-gate #define	TNSZy(name, amode, sz)	{TERM, amode,  0, 1, 0, 0}
2997c478bd9Sstevel@tonic-gate #define	TS(name, amode)		{TERM, amode,  0, 0, 0, 0}
3007c478bd9Sstevel@tonic-gate #define	TSx(name, amode)	{TERM, amode,  1, 0, 0, 0}
3017c478bd9Sstevel@tonic-gate #define	TSy(name, amode)	{TERM, amode,  0, 1, 0, 0}
3027c478bd9Sstevel@tonic-gate #define	TSp(name, amode)	{TERM, amode,  0, 0, 0, 1}
3037c478bd9Sstevel@tonic-gate #define	TSZ(name, amode, sz)	{TERM, amode,  0, 0, 0, 0}
3047c478bd9Sstevel@tonic-gate #define	TSZx(name, amode, sz)	{TERM, amode,  1, 0, 0, 0}
3057c478bd9Sstevel@tonic-gate #define	TSZy(name, amode, sz)	{TERM, amode,  0, 1, 0, 0}
3067c478bd9Sstevel@tonic-gate #define	INVALID			{TERM, UNKNOWN, 0, 0, 0, 0}
3077c478bd9Sstevel@tonic-gate #endif
3087c478bd9Sstevel@tonic-gate 
3097c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
3107c478bd9Sstevel@tonic-gate /*
3117c478bd9Sstevel@tonic-gate  * this decodes the r_m field for mode's 0, 1, 2 in 16 bit mode
3127c478bd9Sstevel@tonic-gate  */
3137c478bd9Sstevel@tonic-gate const char *const dis_addr16[3][8] = {
3147c478bd9Sstevel@tonic-gate "(%bx,%si)", "(%bx,%di)", "(%bp,%si)", "(%bp,%di)", "(%si)", "(%di)", "",
3157c478bd9Sstevel@tonic-gate 									"(%bx)",
3167c478bd9Sstevel@tonic-gate "(%bx,%si)", "(%bx,%di)", "(%bp,%si)", "(%bp,%di)", "(%si)", "(%di", "(%bp)",
3177c478bd9Sstevel@tonic-gate 									"(%bx)",
3187c478bd9Sstevel@tonic-gate "(%bx,%si)", "(%bx,%di)", "(%bp,%si)", "(%bp,%di)", "(%si)", "(%di)", "(%bp)",
3197c478bd9Sstevel@tonic-gate 									"(%bx)",
3207c478bd9Sstevel@tonic-gate };
3217c478bd9Sstevel@tonic-gate 
3227c478bd9Sstevel@tonic-gate 
3237c478bd9Sstevel@tonic-gate /*
3247c478bd9Sstevel@tonic-gate  * This decodes 32 bit addressing mode r_m field for modes 0, 1, 2
3257c478bd9Sstevel@tonic-gate  */
3267c478bd9Sstevel@tonic-gate const char *const dis_addr32_mode0[16] = {
3277c478bd9Sstevel@tonic-gate   "(%eax)", "(%ecx)", "(%edx)",  "(%ebx)",  "", "",        "(%esi)",  "(%edi)",
3287c478bd9Sstevel@tonic-gate   "(%r8d)", "(%r9d)", "(%r10d)", "(%r11d)", "", "",        "(%r14d)", "(%r15d)"
3297c478bd9Sstevel@tonic-gate };
3307c478bd9Sstevel@tonic-gate 
3317c478bd9Sstevel@tonic-gate const char *const dis_addr32_mode12[16] = {
3327c478bd9Sstevel@tonic-gate   "(%eax)", "(%ecx)", "(%edx)",  "(%ebx)",  "", "(%ebp)",  "(%esi)",  "(%edi)",
3337c478bd9Sstevel@tonic-gate   "(%r8d)", "(%r9d)", "(%r10d)", "(%r11d)", "", "(%r13d)", "(%r14d)", "(%r15d)"
3347c478bd9Sstevel@tonic-gate };
3357c478bd9Sstevel@tonic-gate 
3367c478bd9Sstevel@tonic-gate /*
3377c478bd9Sstevel@tonic-gate  * This decodes 64 bit addressing mode r_m field for modes 0, 1, 2
3387c478bd9Sstevel@tonic-gate  */
3397c478bd9Sstevel@tonic-gate const char *const dis_addr64_mode0[16] = {
3407c478bd9Sstevel@tonic-gate  "(%rax)", "(%rcx)", "(%rdx)", "(%rbx)", "",       "(%rip)", "(%rsi)", "(%rdi)",
3417c478bd9Sstevel@tonic-gate  "(%r8)",  "(%r9)",  "(%r10)", "(%r11)", "(%r12)", "(%rip)", "(%r14)", "(%r15)"
3427c478bd9Sstevel@tonic-gate };
3437c478bd9Sstevel@tonic-gate const char *const dis_addr64_mode12[16] = {
3447c478bd9Sstevel@tonic-gate  "(%rax)", "(%rcx)", "(%rdx)", "(%rbx)", "",       "(%rbp)", "(%rsi)", "(%rdi)",
3457c478bd9Sstevel@tonic-gate  "(%r8)",  "(%r9)",  "(%r10)", "(%r11)", "(%r12)", "(%r13)", "(%r14)", "(%r15)"
3467c478bd9Sstevel@tonic-gate };
3477c478bd9Sstevel@tonic-gate 
3487c478bd9Sstevel@tonic-gate /*
3497c478bd9Sstevel@tonic-gate  * decode for scale from SIB byte
3507c478bd9Sstevel@tonic-gate  */
3517c478bd9Sstevel@tonic-gate const char *const dis_scale_factor[4] = { ")", ",2)", ",4)", ",8)" };
3527c478bd9Sstevel@tonic-gate 
3537c478bd9Sstevel@tonic-gate /*
3547c478bd9Sstevel@tonic-gate  * register decoding for normal references to registers (ie. not addressing)
3557c478bd9Sstevel@tonic-gate  */
3567c478bd9Sstevel@tonic-gate const char *const dis_REG8[16] = {
3577c478bd9Sstevel@tonic-gate 	"%al",  "%cl",  "%dl",   "%bl",   "%ah",   "%ch",   "%dh",   "%bh",
3587c478bd9Sstevel@tonic-gate 	"%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
3597c478bd9Sstevel@tonic-gate };
3607c478bd9Sstevel@tonic-gate 
3617c478bd9Sstevel@tonic-gate const char *const dis_REG8_REX[16] = {
3627c478bd9Sstevel@tonic-gate 	"%al",  "%cl",  "%dl",   "%bl",   "%spl",  "%bpl",  "%sil",  "%dil",
3637c478bd9Sstevel@tonic-gate 	"%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
3647c478bd9Sstevel@tonic-gate };
3657c478bd9Sstevel@tonic-gate 
3667c478bd9Sstevel@tonic-gate const char *const dis_REG16[16] = {
3677c478bd9Sstevel@tonic-gate 	"%ax",  "%cx",  "%dx",   "%bx",   "%sp",   "%bp",   "%si",   "%di",
3687c478bd9Sstevel@tonic-gate 	"%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
3697c478bd9Sstevel@tonic-gate };
3707c478bd9Sstevel@tonic-gate 
3717c478bd9Sstevel@tonic-gate const char *const dis_REG32[16] = {
3727c478bd9Sstevel@tonic-gate 	"%eax", "%ecx", "%edx",  "%ebx",  "%esp",  "%ebp",  "%esi",  "%edi",
3737c478bd9Sstevel@tonic-gate 	"%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
3747c478bd9Sstevel@tonic-gate };
3757c478bd9Sstevel@tonic-gate 
3767c478bd9Sstevel@tonic-gate const char *const dis_REG64[16] = {
3777c478bd9Sstevel@tonic-gate 	"%rax", "%rcx", "%rdx",  "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
3787c478bd9Sstevel@tonic-gate 	"%r8",  "%r9",  "%r10",  "%r11", "%r12", "%r13", "%r14", "%r15"
3797c478bd9Sstevel@tonic-gate };
3807c478bd9Sstevel@tonic-gate 
3817c478bd9Sstevel@tonic-gate const char *const dis_DEBUGREG[16] = {
3827c478bd9Sstevel@tonic-gate 	"%db0", "%db1", "%db2",  "%db3",  "%db4",  "%db5",  "%db6",  "%db7",
3837c478bd9Sstevel@tonic-gate 	"%db8", "%db9", "%db10", "%db11", "%db12", "%db13", "%db14", "%db15"
3847c478bd9Sstevel@tonic-gate };
3857c478bd9Sstevel@tonic-gate 
3867c478bd9Sstevel@tonic-gate const char *const dis_CONTROLREG[16] = {
3877c478bd9Sstevel@tonic-gate     "%cr0", "%cr1", "%cr2", "%cr3", "%cr4", "%cr5?", "%cr6?", "%cr7?",
3887c478bd9Sstevel@tonic-gate     "%cr8", "%cr9?", "%cr10?", "%cr11?", "%cr12?", "%cr13?", "%cr14?", "%cr15?"
3897c478bd9Sstevel@tonic-gate };
3907c478bd9Sstevel@tonic-gate 
3917c478bd9Sstevel@tonic-gate const char *const dis_TESTREG[16] = {
3927c478bd9Sstevel@tonic-gate 	"%tr0?", "%tr1?", "%tr2?", "%tr3", "%tr4", "%tr5", "%tr6", "%tr7",
3937c478bd9Sstevel@tonic-gate 	"%tr0?", "%tr1?", "%tr2?", "%tr3", "%tr4", "%tr5", "%tr6", "%tr7"
3947c478bd9Sstevel@tonic-gate };
3957c478bd9Sstevel@tonic-gate 
3967c478bd9Sstevel@tonic-gate const char *const dis_MMREG[16] = {
3977c478bd9Sstevel@tonic-gate 	"%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7",
3987c478bd9Sstevel@tonic-gate 	"%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7"
3997c478bd9Sstevel@tonic-gate };
4007c478bd9Sstevel@tonic-gate 
4017c478bd9Sstevel@tonic-gate const char *const dis_XMMREG[16] = {
4027c478bd9Sstevel@tonic-gate     "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7",
4037c478bd9Sstevel@tonic-gate     "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", "%xmm15"
4047c478bd9Sstevel@tonic-gate };
4057c478bd9Sstevel@tonic-gate 
4067c478bd9Sstevel@tonic-gate const char *const dis_SEGREG[16] = {
4077c478bd9Sstevel@tonic-gate 	"%es", "%cs", "%ss", "%ds", "%fs", "%gs", "<reserved>", "<reserved>",
4087c478bd9Sstevel@tonic-gate 	"%es", "%cs", "%ss", "%ds", "%fs", "%gs", "<reserved>", "<reserved>"
4097c478bd9Sstevel@tonic-gate };
4107c478bd9Sstevel@tonic-gate 
4117c478bd9Sstevel@tonic-gate /*
4127c478bd9Sstevel@tonic-gate  * SIMD predicate suffixes
4137c478bd9Sstevel@tonic-gate  */
4147c478bd9Sstevel@tonic-gate const char *const dis_PREDSUFFIX[8] = {
4157c478bd9Sstevel@tonic-gate 	"eq", "lt", "le", "unord", "neq", "nlt", "nle", "ord"
4167c478bd9Sstevel@tonic-gate };
4177c478bd9Sstevel@tonic-gate 
4187c478bd9Sstevel@tonic-gate 
4197c478bd9Sstevel@tonic-gate 
4207c478bd9Sstevel@tonic-gate #endif	/* DIS_TEXT */
4217c478bd9Sstevel@tonic-gate 
4227c478bd9Sstevel@tonic-gate 
4237c478bd9Sstevel@tonic-gate 
4247c478bd9Sstevel@tonic-gate 
4257c478bd9Sstevel@tonic-gate /*
4267c478bd9Sstevel@tonic-gate  *	"decode table" for 64 bit mode MOVSXD instruction (opcode 0x63)
4277c478bd9Sstevel@tonic-gate  */
4287c478bd9Sstevel@tonic-gate const instable_t dis_opMOVSLD = TNS("movslq",MOVSXZ);
4297c478bd9Sstevel@tonic-gate 
4307c478bd9Sstevel@tonic-gate /*
4317c478bd9Sstevel@tonic-gate  *	"decode table" for pause and clflush instructions
4327c478bd9Sstevel@tonic-gate  */
4337c478bd9Sstevel@tonic-gate const instable_t dis_opPause = TNS("pause", NORM);
4347c478bd9Sstevel@tonic-gate 
4357c478bd9Sstevel@tonic-gate /*
4367c478bd9Sstevel@tonic-gate  *	Decode table for 0x0F00 opcodes
4377c478bd9Sstevel@tonic-gate  */
4387c478bd9Sstevel@tonic-gate const instable_t dis_op0F00[8] = {
4397c478bd9Sstevel@tonic-gate 
4407c478bd9Sstevel@tonic-gate /*  [0]  */	TNS("sldt",M),		TNS("str",M),		TNSy("lldt",M), 	TNSy("ltr",M),
4417c478bd9Sstevel@tonic-gate /*  [4]  */	TNSZ("verr",M,2),	TNSZ("verw",M,2),	INVALID,		INVALID,
4427c478bd9Sstevel@tonic-gate };
4437c478bd9Sstevel@tonic-gate 
4447c478bd9Sstevel@tonic-gate 
4457c478bd9Sstevel@tonic-gate /*
4467c478bd9Sstevel@tonic-gate  *	Decode table for 0x0F01 opcodes
4477c478bd9Sstevel@tonic-gate  */
4487c478bd9Sstevel@tonic-gate const instable_t dis_op0F01[8] = {
4497c478bd9Sstevel@tonic-gate 
4507c478bd9Sstevel@tonic-gate /*  [0]  */	TNSZ("sgdt",MO,6),	TNSZ("sidt",MO,6), 	TNSZ("lgdt",MO,6),	TNSZ("lidt",MO,6),
4517c478bd9Sstevel@tonic-gate /*  [4]  */	TNSZ("smsw",M,2),	INVALID, 		TNSZ("lmsw",M,2),	TNS("invlpg",SWAPGS),
4527c478bd9Sstevel@tonic-gate };
4537c478bd9Sstevel@tonic-gate 
4547c478bd9Sstevel@tonic-gate /*
4557c478bd9Sstevel@tonic-gate  *	Decode table for 0x0F18 opcodes -- SIMD prefetch
4567c478bd9Sstevel@tonic-gate  */
4577c478bd9Sstevel@tonic-gate const instable_t dis_op0F18[8] = {
4587c478bd9Sstevel@tonic-gate 
4597c478bd9Sstevel@tonic-gate /*  [0]  */	TNS("prefetchnta",PREF),TNS("prefetcht0",PREF),	TNS("prefetcht1",PREF),	TNS("prefetcht2",PREF),
4607c478bd9Sstevel@tonic-gate /*  [4]  */	INVALID,		INVALID,		INVALID,		INVALID,
4617c478bd9Sstevel@tonic-gate };
4627c478bd9Sstevel@tonic-gate 
4637c478bd9Sstevel@tonic-gate /*
4647c478bd9Sstevel@tonic-gate  * 	Decode table for 0x0FAE opcodes -- SIMD state save/restore
4657c478bd9Sstevel@tonic-gate  */
4667c478bd9Sstevel@tonic-gate const instable_t dis_op0FAE[8] = {
4677c478bd9Sstevel@tonic-gate /*  [0]  */	TNSZ("fxsave",M,512),	TNSZ("fxrstor",M,512),	TNS("ldmxcsr",M),	TNS("stmxcsr",M),
4687c478bd9Sstevel@tonic-gate /*  [4]  */	INVALID,		TNS("lfence",XMMFENCE), TNS("mfence",XMMFENCE),	TNS("sfence",XMMSFNC),
4697c478bd9Sstevel@tonic-gate };
4707c478bd9Sstevel@tonic-gate 
4717c478bd9Sstevel@tonic-gate /*
4727c478bd9Sstevel@tonic-gate  *	Decode table for 0x0FBA opcodes
4737c478bd9Sstevel@tonic-gate  */
4747c478bd9Sstevel@tonic-gate 
4757c478bd9Sstevel@tonic-gate const instable_t dis_op0FBA[8] = {
4767c478bd9Sstevel@tonic-gate 
4777c478bd9Sstevel@tonic-gate /*  [0]  */	INVALID,		INVALID,		INVALID,		INVALID,
4787c478bd9Sstevel@tonic-gate /*  [4]  */	TS("bt",MIb),		TS("bts",MIb),		TS("btr",MIb),		TS("btc",MIb),
4797c478bd9Sstevel@tonic-gate };
4807c478bd9Sstevel@tonic-gate 
4817c478bd9Sstevel@tonic-gate /*
4827c478bd9Sstevel@tonic-gate  * 	Decode table for 0x0FC7 opcode
4837c478bd9Sstevel@tonic-gate  */
4847c478bd9Sstevel@tonic-gate 
4857c478bd9Sstevel@tonic-gate const instable_t dis_op0FC7[8] = {
4867c478bd9Sstevel@tonic-gate 
4877c478bd9Sstevel@tonic-gate /*  [0]  */	INVALID,		TNS("cmpxchg8b",M),	INVALID,		INVALID,
4887c478bd9Sstevel@tonic-gate /*  [4]  */	INVALID,		INVALID,	INVALID,		 INVALID,
4897c478bd9Sstevel@tonic-gate };
4907c478bd9Sstevel@tonic-gate 
4917c478bd9Sstevel@tonic-gate 
4927c478bd9Sstevel@tonic-gate /*
4937c478bd9Sstevel@tonic-gate  *	Decode table for 0x0FC8 opcode -- 486 bswap instruction
4947c478bd9Sstevel@tonic-gate  *
4957c478bd9Sstevel@tonic-gate  *bit pattern: 0000 1111 1100 1reg
4967c478bd9Sstevel@tonic-gate  */
4977c478bd9Sstevel@tonic-gate const instable_t dis_op0FC8[4] = {
4987c478bd9Sstevel@tonic-gate /*  [0]  */	TNS("bswap",R),		INVALID,		INVALID,		INVALID,
4997c478bd9Sstevel@tonic-gate };
5007c478bd9Sstevel@tonic-gate 
5017c478bd9Sstevel@tonic-gate /*
5027c478bd9Sstevel@tonic-gate  *	Decode table for 0x0F71, 0x0F72, and 0x0F73 opcodes -- MMX instructions
5037c478bd9Sstevel@tonic-gate  */
5047c478bd9Sstevel@tonic-gate const instable_t dis_op0F7123[4][8] = {
5057c478bd9Sstevel@tonic-gate {
5067c478bd9Sstevel@tonic-gate /*  [70].0 */	INVALID,		INVALID,		INVALID,		INVALID,
5077c478bd9Sstevel@tonic-gate /*      .4 */	INVALID,		INVALID,		INVALID,		INVALID,
5087c478bd9Sstevel@tonic-gate }, {
5097c478bd9Sstevel@tonic-gate /*  [71].0 */	INVALID,		INVALID,		TNS("psrlw",MMOSH),	INVALID,
5107c478bd9Sstevel@tonic-gate /*      .4 */	TNS("psraw",MMOSH),	INVALID,		TNS("psllw",MMOSH),	INVALID,
5117c478bd9Sstevel@tonic-gate }, {
5127c478bd9Sstevel@tonic-gate /*  [72].0 */	INVALID,		INVALID,		TNS("psrld",MMOSH),	INVALID,
5137c478bd9Sstevel@tonic-gate /*      .4 */	TNS("psrad",MMOSH),	INVALID,		TNS("pslld",MMOSH),	INVALID,
5147c478bd9Sstevel@tonic-gate }, {
5157c478bd9Sstevel@tonic-gate /*  [73].0 */	INVALID,		INVALID,		TNS("psrlq",MMOSH),	TNS("INVALID",MMOSH),
5167c478bd9Sstevel@tonic-gate /*      .4 */	INVALID,		INVALID, 		TNS("psllq",MMOSH),	TNS("INVALID",MMOSH),
5177c478bd9Sstevel@tonic-gate } };
5187c478bd9Sstevel@tonic-gate 
5197c478bd9Sstevel@tonic-gate /*
5207c478bd9Sstevel@tonic-gate  *	Decode table for SIMD extensions to above 0x0F71-0x0F73 opcodes.
5217c478bd9Sstevel@tonic-gate  */
5227c478bd9Sstevel@tonic-gate const instable_t dis_opSIMD7123[32] = {
5237c478bd9Sstevel@tonic-gate /* [70].0 */	INVALID,		INVALID,		INVALID,		INVALID,
5247c478bd9Sstevel@tonic-gate /*     .4 */	INVALID,		INVALID,		INVALID,		INVALID,
5257c478bd9Sstevel@tonic-gate 
5267c478bd9Sstevel@tonic-gate /* [71].0 */	INVALID,		INVALID,		TNS("psrlw",XMMSH),	INVALID,
5277c478bd9Sstevel@tonic-gate /*     .4 */	TNS("psraw",XMMSH),	INVALID,		TNS("psllw",XMMSH),	INVALID,
5287c478bd9Sstevel@tonic-gate 
5297c478bd9Sstevel@tonic-gate /* [72].0 */	INVALID,		INVALID,		TNS("psrld",XMMSH),	INVALID,
5307c478bd9Sstevel@tonic-gate /*     .4 */	TNS("psrad",XMMSH),	INVALID,		TNS("pslld",XMMSH),	INVALID,
5317c478bd9Sstevel@tonic-gate 
5327c478bd9Sstevel@tonic-gate /* [73].0 */	INVALID,		INVALID,		TNS("psrlq",XMMSH),	TNS("psrldq",XMMSH),
5337c478bd9Sstevel@tonic-gate /*     .4 */	INVALID,		INVALID,		TNS("psllq",XMMSH),	TNS("pslldq",XMMSH),
5347c478bd9Sstevel@tonic-gate };
5357c478bd9Sstevel@tonic-gate 
5367c478bd9Sstevel@tonic-gate /*
5377c478bd9Sstevel@tonic-gate  *	SIMD instructions have been wedged into the existing IA32 instruction
5387c478bd9Sstevel@tonic-gate  *	set through the use of prefixes.  That is, while 0xf0 0x58 may be
5397c478bd9Sstevel@tonic-gate  *	addps, 0xf3 0xf0 0x58 (literally, repz addps) is a completely different
5407c478bd9Sstevel@tonic-gate  *	instruction - addss.  At present, three prefixes have been coopted in
5417c478bd9Sstevel@tonic-gate  *	this manner - address size (0x66), repnz (0xf2) and repz (0xf3).  The
5427c478bd9Sstevel@tonic-gate  *	following tables are used to provide the prefixed instruction names.
5437c478bd9Sstevel@tonic-gate  *	The arrays are sparse, but they're fast.
5447c478bd9Sstevel@tonic-gate  */
5457c478bd9Sstevel@tonic-gate 
5467c478bd9Sstevel@tonic-gate /*
5477c478bd9Sstevel@tonic-gate  *	Decode table for SIMD instructions with the address size (0x66) prefix.
5487c478bd9Sstevel@tonic-gate  */
5497c478bd9Sstevel@tonic-gate const instable_t dis_opSIMDdata16[256] = {
5507c478bd9Sstevel@tonic-gate /*  [00]  */	INVALID,		INVALID,		INVALID,		INVALID,
5517c478bd9Sstevel@tonic-gate /*  [04]  */	INVALID,		INVALID,		INVALID,		INVALID,
5527c478bd9Sstevel@tonic-gate /*  [08]  */	INVALID,		INVALID,		INVALID,		INVALID,
5537c478bd9Sstevel@tonic-gate /*  [0C]  */	INVALID,		INVALID,		INVALID,		INVALID,
5547c478bd9Sstevel@tonic-gate 
5557c478bd9Sstevel@tonic-gate /*  [10]  */	TNSZ("movupd",XMM,16),	TNSZ("movupd",XMMS,16),	TNSZ("movlpd",XMMM,8),	TNSZ("movlpd",XMMMS,8),
5567c478bd9Sstevel@tonic-gate /*  [14]  */	TNSZ("unpcklpd",XMM,16),TNSZ("unpckhpd",XMM,16),TNSZ("movhpd",XMMM,8),	TNSZ("movhpd",XMMMS,8),
5577c478bd9Sstevel@tonic-gate /*  [18]  */	INVALID,		INVALID,		INVALID,		INVALID,
5587c478bd9Sstevel@tonic-gate /*  [1C]  */	INVALID,		INVALID,		INVALID,		INVALID,
5597c478bd9Sstevel@tonic-gate 
5607c478bd9Sstevel@tonic-gate /*  [20]  */	INVALID,		INVALID,		INVALID,		INVALID,
5617c478bd9Sstevel@tonic-gate /*  [24]  */	INVALID,		INVALID,		INVALID,		INVALID,
5627c478bd9Sstevel@tonic-gate /*  [28]  */	TNSZ("movapd",XMM,16),	TNSZ("movapd",XMMS,16),	TNSZ("cvtpi2pd",XMMOMX,8),TNSZ("movntpd",XMMOMS,16),
5637c478bd9Sstevel@tonic-gate /*  [2C]  */	TNSZ("cvttpd2pi",XMMXMM,16),TNSZ("cvtpd2pi",XMMXMM,16),TNSZ("ucomisd",XMM,8),TNSZ("comisd",XMM,8),
5647c478bd9Sstevel@tonic-gate 
5657c478bd9Sstevel@tonic-gate /*  [30]  */	INVALID,		INVALID,		INVALID,		INVALID,
5667c478bd9Sstevel@tonic-gate /*  [34]  */	INVALID,		INVALID,		INVALID,		INVALID,
5677c478bd9Sstevel@tonic-gate /*  [38]  */	INVALID,		INVALID,		INVALID,		INVALID,
5687c478bd9Sstevel@tonic-gate /*  [3C]  */	INVALID,		INVALID,		INVALID,		INVALID,
5697c478bd9Sstevel@tonic-gate 
5707c478bd9Sstevel@tonic-gate /*  [40]  */	INVALID,		INVALID,		INVALID,		INVALID,
5717c478bd9Sstevel@tonic-gate /*  [44]  */	INVALID,		INVALID,		INVALID,		INVALID,
5727c478bd9Sstevel@tonic-gate /*  [48]  */	INVALID,		INVALID,		INVALID,		INVALID,
5737c478bd9Sstevel@tonic-gate /*  [4C]  */	INVALID,		INVALID,		INVALID,		INVALID,
5747c478bd9Sstevel@tonic-gate 
5757c478bd9Sstevel@tonic-gate /*  [50]  */	TNS("movmskpd",XMMOX3),	TNSZ("sqrtpd",XMM,16),	INVALID,		INVALID,
5767c478bd9Sstevel@tonic-gate /*  [54]  */	TNSZ("andpd",XMM,16),	TNSZ("andnpd",XMM,16),	TNSZ("orpd",XMM,16),	TNSZ("xorpd",XMM,16),
5777c478bd9Sstevel@tonic-gate /*  [58]  */	TNSZ("addpd",XMM,16),	TNSZ("mulpd",XMM,16),	TNSZ("cvtpd2ps",XMM,16),TNSZ("cvtps2dq",XMM,16),
5787c478bd9Sstevel@tonic-gate /*  [5C]  */	TNSZ("subpd",XMM,16),	TNSZ("minpd",XMM,16),	TNSZ("divpd",XMM,16),	TNSZ("maxpd",XMM,16),
5797c478bd9Sstevel@tonic-gate 
5807c478bd9Sstevel@tonic-gate /*  [60]  */	TNSZ("punpcklbw",XMM,16),TNSZ("punpcklwd",XMM,16),TNSZ("punpckldq",XMM,16),TNSZ("packsswb",XMM,16),
5817c478bd9Sstevel@tonic-gate /*  [64]  */	TNSZ("pcmpgtb",XMM,16),	TNSZ("pcmpgtw",XMM,16),	TNSZ("pcmpgtd",XMM,16),	TNSZ("packuswb",XMM,16),
5827c478bd9Sstevel@tonic-gate /*  [68]  */	TNSZ("punpckhbw",XMM,16),TNSZ("punpckhwd",XMM,16),TNSZ("punpckhdq",XMM,16),TNSZ("packssdw",XMM,16),
5837c478bd9Sstevel@tonic-gate /*  [6C]  */	TNSZ("punpcklqdq",XMM,16),TNSZ("punpckhqdq",XMM,16),TNSZ("movd",XMM3MX,4),TNSZ("movdqa",XMM,16),
5847c478bd9Sstevel@tonic-gate 
5857c478bd9Sstevel@tonic-gate /*  [70]  */	TNSZ("pshufd",XMMP,16),	INVALID,		INVALID,		INVALID,
5867c478bd9Sstevel@tonic-gate /*  [74]  */	TNSZ("pcmpeqb",XMM,16),	TNSZ("pcmpeqw",XMM,16),	TNSZ("pcmpeqd",XMM,16),	INVALID,
5877c478bd9Sstevel@tonic-gate /*  [78]  */	INVALID,		INVALID,		INVALID,		INVALID,
5887c478bd9Sstevel@tonic-gate /*  [7C]  */	INVALID,		INVALID,		TNSZ("movd",XMM3MXS,4),	TNSZ("movdqa",XMMS,16),
5897c478bd9Sstevel@tonic-gate 
5907c478bd9Sstevel@tonic-gate /*  [80]  */	INVALID,		INVALID,		INVALID,		INVALID,
5917c478bd9Sstevel@tonic-gate /*  [84]  */	INVALID,		INVALID,		INVALID,		INVALID,
5927c478bd9Sstevel@tonic-gate /*  [88]  */	INVALID,		INVALID,		INVALID,		INVALID,
5937c478bd9Sstevel@tonic-gate /*  [8C]  */	INVALID,		INVALID,		INVALID,		INVALID,
5947c478bd9Sstevel@tonic-gate 
5957c478bd9Sstevel@tonic-gate /*  [90]  */	INVALID,		INVALID,		INVALID,		INVALID,
5967c478bd9Sstevel@tonic-gate /*  [94]  */	INVALID,		INVALID,		INVALID,		INVALID,
5977c478bd9Sstevel@tonic-gate /*  [98]  */	INVALID,		INVALID,		INVALID,		INVALID,
5987c478bd9Sstevel@tonic-gate /*  [9C]  */	INVALID,		INVALID,		INVALID,		INVALID,
5997c478bd9Sstevel@tonic-gate 
6007c478bd9Sstevel@tonic-gate /*  [A0]  */	INVALID,		INVALID,		INVALID,		INVALID,
6017c478bd9Sstevel@tonic-gate /*  [A4]  */	INVALID,		INVALID,		INVALID,		INVALID,
6027c478bd9Sstevel@tonic-gate /*  [A8]  */	INVALID,		INVALID,		INVALID,		INVALID,
6037c478bd9Sstevel@tonic-gate /*  [AC]  */	INVALID,		INVALID,		INVALID,		INVALID,
6047c478bd9Sstevel@tonic-gate 
6057c478bd9Sstevel@tonic-gate /*  [B0]  */	INVALID,		INVALID,		INVALID,		INVALID,
6067c478bd9Sstevel@tonic-gate /*  [B4]  */	INVALID,		INVALID,		INVALID,		INVALID,
6077c478bd9Sstevel@tonic-gate /*  [B8]  */	INVALID,		INVALID,		INVALID,		INVALID,
6087c478bd9Sstevel@tonic-gate /*  [BC]  */	INVALID,		INVALID,		INVALID,		INVALID,
6097c478bd9Sstevel@tonic-gate 
6107c478bd9Sstevel@tonic-gate /*  [C0]  */	INVALID,		INVALID,		TNSZ("cmppd",XMMP,16),	INVALID,
6117c478bd9Sstevel@tonic-gate /*  [C4]  */	TNSZ("pinsrw",XMMPRM,2),TNS("pextrw",XMM3P),	TNSZ("shufpd",XMMP,16),	INVALID,
6127c478bd9Sstevel@tonic-gate /*  [C8]  */	INVALID,		INVALID,		INVALID,		INVALID,
6137c478bd9Sstevel@tonic-gate /*  [CC]  */	INVALID,		INVALID,		INVALID,		INVALID,
6147c478bd9Sstevel@tonic-gate 
6157c478bd9Sstevel@tonic-gate /*  [D0]  */	INVALID,		TNSZ("psrlw",XMM,16),	TNSZ("psrld",XMM,16),	TNSZ("psrlq",XMM,16),
6167c478bd9Sstevel@tonic-gate /*  [D4]  */	TNSZ("paddq",XMM,16),	TNSZ("pmullw",XMM,16),	TNSZ("movq",XMMS,8),	TNS("pmovmskb",XMMX3),
6177c478bd9Sstevel@tonic-gate /*  [D8]  */	TNSZ("psubusb",XMM,16),	TNSZ("psubusw",XMM,16),	TNSZ("pminub",XMM,16),	TNSZ("pand",XMM,16),
6187c478bd9Sstevel@tonic-gate /*  [DC]  */	TNSZ("paddusb",XMM,16),	TNSZ("paddusw",XMM,16),	TNSZ("pmaxub",XMM,16),	TNSZ("pandn",XMM,16),
6197c478bd9Sstevel@tonic-gate 
6207c478bd9Sstevel@tonic-gate /*  [E0]  */	TNSZ("pavgb",XMM,16),	TNSZ("psraw",XMM,16),	TNSZ("psrad",XMM,16),	TNSZ("pavgw",XMM,16),
6217c478bd9Sstevel@tonic-gate /*  [E4]  */	TNSZ("pmulhuw",XMM,16),	TNSZ("pmulhw",XMM,16),	TNSZ("cvttpd2dq",XMM,16),TNSZ("movntdq",XMMS,16),
6227c478bd9Sstevel@tonic-gate /*  [E8]  */	TNSZ("psubsb",XMM,16),	TNSZ("psubsw",XMM,16),	TNSZ("pminsw",XMM,16),	TNSZ("por",XMM,16),
6237c478bd9Sstevel@tonic-gate /*  [EC]  */	TNSZ("paddsb",XMM,16),	TNSZ("paddsw",XMM,16),	TNSZ("pmaxsw",XMM,16),	TNSZ("pxor",XMM,16),
6247c478bd9Sstevel@tonic-gate 
6257c478bd9Sstevel@tonic-gate /*  [F0]  */	INVALID,		TNSZ("psllw",XMM,16),	TNSZ("pslld",XMM,16),	TNSZ("psllq",XMM,16),
6267c478bd9Sstevel@tonic-gate /*  [F4]  */	TNSZ("pmuludq",XMM,16),	TNSZ("pmaddwd",XMM,16),	TNSZ("psadbw",XMM,16),	TNSZ("maskmovdqu", XMMXIMPL,16),
6277c478bd9Sstevel@tonic-gate /*  [F8]  */	TNSZ("psubb",XMM,16),	TNSZ("psubw",XMM,16),	TNSZ("psubd",XMM,16),	TNSZ("psubq",XMM,16),
6287c478bd9Sstevel@tonic-gate /*  [FC]  */	TNSZ("paddb",XMM,16),	TNSZ("paddw",XMM,16),	TNSZ("paddd",XMM,16),	INVALID,
6297c478bd9Sstevel@tonic-gate };
6307c478bd9Sstevel@tonic-gate 
6317c478bd9Sstevel@tonic-gate /*
6327c478bd9Sstevel@tonic-gate  *	Decode table for SIMD instructions with the repnz (0xf2) prefix.
6337c478bd9Sstevel@tonic-gate  */
6347c478bd9Sstevel@tonic-gate const instable_t dis_opSIMDrepnz[256] = {
6357c478bd9Sstevel@tonic-gate /*  [00]  */	INVALID,		INVALID,		INVALID,		INVALID,
6367c478bd9Sstevel@tonic-gate /*  [04]  */	INVALID,		INVALID,		INVALID,		INVALID,
6377c478bd9Sstevel@tonic-gate /*  [08]  */	INVALID,		INVALID,		INVALID,		INVALID,
6387c478bd9Sstevel@tonic-gate /*  [0C]  */	INVALID,		INVALID,		INVALID,		INVALID,
6397c478bd9Sstevel@tonic-gate 
6407c478bd9Sstevel@tonic-gate /*  [10]  */	TNSZ("movsd",XMM,8),	TNSZ("movsd",XMMS,8),	INVALID,		INVALID,
6417c478bd9Sstevel@tonic-gate /*  [14]  */	INVALID,		INVALID,		INVALID,		INVALID,
6427c478bd9Sstevel@tonic-gate /*  [18]  */	INVALID,		INVALID,		INVALID,		INVALID,
6437c478bd9Sstevel@tonic-gate /*  [1C]  */	INVALID,		INVALID,		INVALID,		INVALID,
6447c478bd9Sstevel@tonic-gate 
6457c478bd9Sstevel@tonic-gate /*  [20]  */	INVALID,		INVALID,		INVALID,		INVALID,
6467c478bd9Sstevel@tonic-gate /*  [24]  */	INVALID,		INVALID,		INVALID,		INVALID,
6477c478bd9Sstevel@tonic-gate /*  [28]  */	INVALID,		INVALID,		TNSZ("cvtsi2sd",XMM3MX,4),INVALID,
6487c478bd9Sstevel@tonic-gate /*  [2C]  */	TNSZ("cvttsd2si",XMMXM3,8),TNSZ("cvtsd2si",XMMXM3,8),INVALID,		INVALID,
6497c478bd9Sstevel@tonic-gate 
6507c478bd9Sstevel@tonic-gate /*  [30]  */	INVALID,		INVALID,		INVALID,		INVALID,
6517c478bd9Sstevel@tonic-gate /*  [34]  */	INVALID,		INVALID,		INVALID,		INVALID,
6527c478bd9Sstevel@tonic-gate /*  [38]  */	INVALID,		INVALID,		INVALID,		INVALID,
6537c478bd9Sstevel@tonic-gate /*  [3C]  */	INVALID,		INVALID,		INVALID,		INVALID,
6547c478bd9Sstevel@tonic-gate 
6557c478bd9Sstevel@tonic-gate /*  [40]  */	INVALID,		INVALID,		INVALID,		INVALID,
6567c478bd9Sstevel@tonic-gate /*  [44]  */	INVALID,		INVALID,		INVALID,		INVALID,
6577c478bd9Sstevel@tonic-gate /*  [48]  */	INVALID,		INVALID,		INVALID,		INVALID,
6587c478bd9Sstevel@tonic-gate /*  [4C]  */	INVALID,		INVALID,		INVALID,		INVALID,
6597c478bd9Sstevel@tonic-gate 
6607c478bd9Sstevel@tonic-gate /*  [50]  */	INVALID,		TNSZ("sqrtsd",XMM,8),	INVALID,		INVALID,
6617c478bd9Sstevel@tonic-gate /*  [54]  */	INVALID,		INVALID,		INVALID,		INVALID,
6627c478bd9Sstevel@tonic-gate /*  [58]  */	TNSZ("addsd",XMM,8),	TNSZ("mulsd",XMM,8),	TNSZ("cvtsd2ss",XMM,8),	INVALID,
6637c478bd9Sstevel@tonic-gate /*  [5C]  */	TNSZ("subsd",XMM,8),	TNSZ("minsd",XMM,8),	TNSZ("divsd",XMM,8),	TNSZ("maxsd",XMM,8),
6647c478bd9Sstevel@tonic-gate 
6657c478bd9Sstevel@tonic-gate /*  [60]  */	INVALID,		INVALID,		INVALID,		INVALID,
6667c478bd9Sstevel@tonic-gate /*  [64]  */	INVALID,		INVALID,		INVALID,		INVALID,
6677c478bd9Sstevel@tonic-gate /*  [68]  */	INVALID,		INVALID,		INVALID,		INVALID,
6687c478bd9Sstevel@tonic-gate /*  [6C]  */	INVALID,		INVALID,		INVALID,		INVALID,
6697c478bd9Sstevel@tonic-gate 
6707c478bd9Sstevel@tonic-gate /*  [70]  */	TNSZ("pshuflw",XMMP,16),INVALID,		INVALID,		INVALID,
6717c478bd9Sstevel@tonic-gate /*  [74]  */	INVALID,		INVALID,		INVALID,		INVALID,
6727c478bd9Sstevel@tonic-gate /*  [78]  */	INVALID,		INVALID,		INVALID,		INVALID,
6737c478bd9Sstevel@tonic-gate /*  [7C]  */	INVALID,		INVALID,		INVALID,		INVALID,
6747c478bd9Sstevel@tonic-gate 
6757c478bd9Sstevel@tonic-gate /*  [80]  */	INVALID,		INVALID,		INVALID,		INVALID,
6767c478bd9Sstevel@tonic-gate /*  [84]  */	INVALID,		INVALID,		INVALID,		INVALID,
6777c478bd9Sstevel@tonic-gate /*  [88]  */	INVALID,		INVALID,		INVALID,		INVALID,
6787c478bd9Sstevel@tonic-gate /*  [0C]  */	INVALID,		INVALID,		INVALID,		INVALID,
6797c478bd9Sstevel@tonic-gate 
6807c478bd9Sstevel@tonic-gate /*  [90]  */	INVALID,		INVALID,		INVALID,		INVALID,
6817c478bd9Sstevel@tonic-gate /*  [94]  */	INVALID,		INVALID,		INVALID,		INVALID,
6827c478bd9Sstevel@tonic-gate /*  [98]  */	INVALID,		INVALID,		INVALID,		INVALID,
6837c478bd9Sstevel@tonic-gate /*  [9C]  */	INVALID,		INVALID,		INVALID,		INVALID,
6847c478bd9Sstevel@tonic-gate 
6857c478bd9Sstevel@tonic-gate /*  [A0]  */	INVALID,		INVALID,		INVALID,		INVALID,
6867c478bd9Sstevel@tonic-gate /*  [A4]  */	INVALID,		INVALID,		INVALID,		INVALID,
6877c478bd9Sstevel@tonic-gate /*  [A8]  */	INVALID,		INVALID,		INVALID,		INVALID,
6887c478bd9Sstevel@tonic-gate /*  [AC]  */	INVALID,		INVALID,		INVALID,		INVALID,
6897c478bd9Sstevel@tonic-gate 
6907c478bd9Sstevel@tonic-gate /*  [B0]  */	INVALID,		INVALID,		INVALID,		INVALID,
6917c478bd9Sstevel@tonic-gate /*  [B4]  */	INVALID,		INVALID,		INVALID,		INVALID,
6927c478bd9Sstevel@tonic-gate /*  [B8]  */	INVALID,		INVALID,		INVALID,		INVALID,
6937c478bd9Sstevel@tonic-gate /*  [BC]  */	INVALID,		INVALID,		INVALID,		INVALID,
6947c478bd9Sstevel@tonic-gate 
6957c478bd9Sstevel@tonic-gate /*  [C0]  */	INVALID,		INVALID,		TNSZ("cmpsd",XMMP,8),	INVALID,
6967c478bd9Sstevel@tonic-gate /*  [C4]  */	INVALID,		INVALID,		INVALID,		INVALID,
6977c478bd9Sstevel@tonic-gate /*  [C8]  */	INVALID,		INVALID,		INVALID,		INVALID,
6987c478bd9Sstevel@tonic-gate /*  [CC]  */	INVALID,		INVALID,		INVALID,		INVALID,
6997c478bd9Sstevel@tonic-gate 
7007c478bd9Sstevel@tonic-gate /*  [D0]  */	INVALID,		INVALID,		INVALID,		INVALID,
7017c478bd9Sstevel@tonic-gate /*  [D4]  */	INVALID,		INVALID,		TNS("movdq2q",XMMXM),	INVALID,
7027c478bd9Sstevel@tonic-gate /*  [D8]  */	INVALID,		INVALID,		INVALID,		INVALID,
7037c478bd9Sstevel@tonic-gate /*  [DC]  */	INVALID,		INVALID,		INVALID,		INVALID,
7047c478bd9Sstevel@tonic-gate 
7057c478bd9Sstevel@tonic-gate /*  [E0]  */	INVALID,		INVALID,		INVALID,		INVALID,
7067c478bd9Sstevel@tonic-gate /*  [E4]  */	INVALID,		INVALID,		TNSZ("cvtpd2dq",XMM,16),INVALID,
7077c478bd9Sstevel@tonic-gate /*  [E8]  */	INVALID,		INVALID,		INVALID,		INVALID,
7087c478bd9Sstevel@tonic-gate /*  [EC]  */	INVALID,		INVALID,		INVALID,		INVALID,
7097c478bd9Sstevel@tonic-gate 
7107c478bd9Sstevel@tonic-gate /*  [F0]  */	INVALID,		INVALID,		INVALID,		INVALID,
7117c478bd9Sstevel@tonic-gate /*  [F4]  */	INVALID,		INVALID,		INVALID,		INVALID,
7127c478bd9Sstevel@tonic-gate /*  [F8]  */	INVALID,		INVALID,		INVALID,		INVALID,
7137c478bd9Sstevel@tonic-gate /*  [FC]  */	INVALID,		INVALID,		INVALID,		INVALID,
7147c478bd9Sstevel@tonic-gate };
7157c478bd9Sstevel@tonic-gate 
7167c478bd9Sstevel@tonic-gate /*
7177c478bd9Sstevel@tonic-gate  *	Decode table for SIMD instructions with the repz (0xf3) prefix.
7187c478bd9Sstevel@tonic-gate  */
7197c478bd9Sstevel@tonic-gate const instable_t dis_opSIMDrepz[256] = {
7207c478bd9Sstevel@tonic-gate /*  [00]  */	INVALID,		INVALID,		INVALID,		INVALID,
7217c478bd9Sstevel@tonic-gate /*  [04]  */	INVALID,		INVALID,		INVALID,		INVALID,
7227c478bd9Sstevel@tonic-gate /*  [08]  */	INVALID,		INVALID,		INVALID,		INVALID,
7237c478bd9Sstevel@tonic-gate /*  [0C]  */	INVALID,		INVALID,		INVALID,		INVALID,
7247c478bd9Sstevel@tonic-gate 
7257c478bd9Sstevel@tonic-gate /*  [10]  */	TNSZ("movss",XMM,4),	TNSZ("movss",XMMS,4),	INVALID,		INVALID,
7267c478bd9Sstevel@tonic-gate /*  [14]  */	INVALID,		INVALID,		INVALID,		INVALID,
7277c478bd9Sstevel@tonic-gate /*  [18]  */	INVALID,		INVALID,		INVALID,		INVALID,
7287c478bd9Sstevel@tonic-gate /*  [1C]  */	INVALID,		INVALID,		INVALID,		INVALID,
7297c478bd9Sstevel@tonic-gate 
7307c478bd9Sstevel@tonic-gate /*  [20]  */	INVALID,		INVALID,		INVALID,		INVALID,
7317c478bd9Sstevel@tonic-gate /*  [24]  */	INVALID,		INVALID,		INVALID,		INVALID,
7327c478bd9Sstevel@tonic-gate /*  [28]  */	INVALID,		INVALID,		TNSZ("cvtsi2ss",XMM3MX,4),INVALID,
7337c478bd9Sstevel@tonic-gate /*  [2C]  */	TNSZ("cvttss2si",XMMXM3,4),TNSZ("cvtss2si",XMMXM3,4),INVALID,		INVALID,
7347c478bd9Sstevel@tonic-gate 
7357c478bd9Sstevel@tonic-gate /*  [30]  */	INVALID,		INVALID,		INVALID,		INVALID,
7367c478bd9Sstevel@tonic-gate /*  [34]  */	INVALID,		INVALID,		INVALID,		INVALID,
7377c478bd9Sstevel@tonic-gate /*  [38]  */	INVALID,		INVALID,		INVALID,		INVALID,
7387c478bd9Sstevel@tonic-gate /*  [3C]  */	INVALID,		INVALID,		INVALID,		INVALID,
7397c478bd9Sstevel@tonic-gate 
7407c478bd9Sstevel@tonic-gate /*  [40]  */	INVALID,		INVALID,		INVALID,		INVALID,
7417c478bd9Sstevel@tonic-gate /*  [44]  */	INVALID,		INVALID,		INVALID,		INVALID,
7427c478bd9Sstevel@tonic-gate /*  [48]  */	INVALID,		INVALID,		INVALID,		INVALID,
7437c478bd9Sstevel@tonic-gate /*  [4C]  */	INVALID,		INVALID,		INVALID,		INVALID,
7447c478bd9Sstevel@tonic-gate 
7457c478bd9Sstevel@tonic-gate /*  [50]  */	INVALID,		TNSZ("sqrtss",XMM,4),	TNSZ("rsqrtss",XMM,4),	TNSZ("rcpss",XMM,4),
7467c478bd9Sstevel@tonic-gate /*  [54]  */	INVALID,		INVALID,		INVALID,		INVALID,
7477c478bd9Sstevel@tonic-gate /*  [58]  */	TNSZ("addss",XMM,4),	TNSZ("mulss",XMM,4),	TNSZ("cvtss2sd",XMM,4),	TNSZ("cvttps2dq",XMM,16),
7487c478bd9Sstevel@tonic-gate /*  [5C]  */	TNSZ("subss",XMM,4),	TNSZ("minss",XMM,4),	TNSZ("divss",XMM,4),	TNSZ("maxss",XMM,4),
7497c478bd9Sstevel@tonic-gate 
7507c478bd9Sstevel@tonic-gate /*  [60]  */	INVALID,		INVALID,		INVALID,		INVALID,
7517c478bd9Sstevel@tonic-gate /*  [64]  */	INVALID,		INVALID,		INVALID,		INVALID,
7527c478bd9Sstevel@tonic-gate /*  [68]  */	INVALID,		INVALID,		INVALID,		INVALID,
7537c478bd9Sstevel@tonic-gate /*  [6C]  */	INVALID,		INVALID,		INVALID,		TNSZ("movdqu",XMM,16),
7547c478bd9Sstevel@tonic-gate 
7557c478bd9Sstevel@tonic-gate /*  [70]  */	TNSZ("pshufhw",XMMP,16),INVALID,		INVALID,		INVALID,
7567c478bd9Sstevel@tonic-gate /*  [74]  */	INVALID,		INVALID,		INVALID,		INVALID,
7577c478bd9Sstevel@tonic-gate /*  [78]  */	INVALID,		INVALID,		INVALID,		INVALID,
7587c478bd9Sstevel@tonic-gate /*  [7C]  */	INVALID,		INVALID,		TNSZ("movq",XMM,8),	TNSZ("movdqu",XMMS,16),
7597c478bd9Sstevel@tonic-gate 
7607c478bd9Sstevel@tonic-gate /*  [80]  */	INVALID,		INVALID,		INVALID,		INVALID,
7617c478bd9Sstevel@tonic-gate /*  [84]  */	INVALID,		INVALID,		INVALID,		INVALID,
7627c478bd9Sstevel@tonic-gate /*  [88]  */	INVALID,		INVALID,		INVALID,		INVALID,
7637c478bd9Sstevel@tonic-gate /*  [0C]  */	INVALID,		INVALID,		INVALID,		INVALID,
7647c478bd9Sstevel@tonic-gate 
7657c478bd9Sstevel@tonic-gate /*  [90]  */	INVALID,		INVALID,		INVALID,		INVALID,
7667c478bd9Sstevel@tonic-gate /*  [94]  */	INVALID,		INVALID,		INVALID,		INVALID,
7677c478bd9Sstevel@tonic-gate /*  [98]  */	INVALID,		INVALID,		INVALID,		INVALID,
7687c478bd9Sstevel@tonic-gate /*  [9C]  */	INVALID,		INVALID,		INVALID,		INVALID,
7697c478bd9Sstevel@tonic-gate 
7707c478bd9Sstevel@tonic-gate /*  [A0]  */	INVALID,		INVALID,		INVALID,		INVALID,
7717c478bd9Sstevel@tonic-gate /*  [A4]  */	INVALID,		INVALID,		INVALID,		INVALID,
7727c478bd9Sstevel@tonic-gate /*  [A8]  */	INVALID,		INVALID,		INVALID,		INVALID,
7737c478bd9Sstevel@tonic-gate /*  [AC]  */	INVALID,		INVALID,		INVALID,		INVALID,
7747c478bd9Sstevel@tonic-gate 
7757c478bd9Sstevel@tonic-gate /*  [B0]  */	INVALID,		INVALID,		INVALID,		INVALID,
7767c478bd9Sstevel@tonic-gate /*  [B4]  */	INVALID,		INVALID,		INVALID,		INVALID,
7777c478bd9Sstevel@tonic-gate /*  [B8]  */	INVALID,		INVALID,		INVALID,		INVALID,
7787c478bd9Sstevel@tonic-gate /*  [BC]  */	INVALID,		INVALID,		INVALID,		INVALID,
7797c478bd9Sstevel@tonic-gate 
7807c478bd9Sstevel@tonic-gate /*  [C0]  */	INVALID,		INVALID,		TNSZ("cmpss",XMMP,4),	INVALID,
7817c478bd9Sstevel@tonic-gate /*  [C4]  */	INVALID,		INVALID,		INVALID,		INVALID,
7827c478bd9Sstevel@tonic-gate /*  [C8]  */	INVALID,		INVALID,		INVALID,		INVALID,
7837c478bd9Sstevel@tonic-gate /*  [CC]  */	INVALID,		INVALID,		INVALID,		INVALID,
7847c478bd9Sstevel@tonic-gate 
7857c478bd9Sstevel@tonic-gate /*  [D0]  */	INVALID,		INVALID,		INVALID,		INVALID,
7867c478bd9Sstevel@tonic-gate /*  [D4]  */	INVALID,		INVALID,		TNS("movq2dq",XMMMX),	INVALID,
7877c478bd9Sstevel@tonic-gate /*  [D8]  */	INVALID,		INVALID,		INVALID,		INVALID,
7887c478bd9Sstevel@tonic-gate /*  [DC]  */	INVALID,		INVALID,		INVALID,		INVALID,
7897c478bd9Sstevel@tonic-gate 
7907c478bd9Sstevel@tonic-gate /*  [E0]  */	INVALID,		INVALID,		INVALID,		INVALID,
7917c478bd9Sstevel@tonic-gate /*  [E4]  */	INVALID,		INVALID,		TNSZ("cvtdq2pd",XMM,8),	INVALID,
7927c478bd9Sstevel@tonic-gate /*  [E8]  */	INVALID,		INVALID,		INVALID,		INVALID,
7937c478bd9Sstevel@tonic-gate /*  [EC]  */	INVALID,		INVALID,		INVALID,		INVALID,
7947c478bd9Sstevel@tonic-gate 
7957c478bd9Sstevel@tonic-gate /*  [F0]  */	INVALID,		INVALID,		INVALID,		INVALID,
7967c478bd9Sstevel@tonic-gate /*  [F4]  */	INVALID,		INVALID,		INVALID,		INVALID,
7977c478bd9Sstevel@tonic-gate /*  [F8]  */	INVALID,		INVALID,		INVALID,		INVALID,
7987c478bd9Sstevel@tonic-gate /*  [FC]  */	INVALID,		INVALID,		INVALID,		INVALID,
7997c478bd9Sstevel@tonic-gate };
8007c478bd9Sstevel@tonic-gate 
8017c478bd9Sstevel@tonic-gate /*
8027c478bd9Sstevel@tonic-gate  *	Decode table for 0x0F opcodes
8037c478bd9Sstevel@tonic-gate  */
8047c478bd9Sstevel@tonic-gate 
8057c478bd9Sstevel@tonic-gate const instable_t dis_op0F[16][16] = {
8067c478bd9Sstevel@tonic-gate {
8077c478bd9Sstevel@tonic-gate /*  [00]  */	IND(dis_op0F00),	IND(dis_op0F01),	TNS("lar",MR),		TNS("lsl",MR),
8087c478bd9Sstevel@tonic-gate /*  [04]  */	INVALID,		TNS("syscall",NORM),	TNS("clts",NORM),	TNS("sysret",NORM),
8097c478bd9Sstevel@tonic-gate /*  [08]  */	TNS("invd",NORM),	TNS("wbinvd",NORM),	INVALID,		TNS("ud2",NORM),
8107c478bd9Sstevel@tonic-gate /*  [0C]  */	INVALID,		INVALID,		INVALID,		INVALID,
8117c478bd9Sstevel@tonic-gate }, {
8127c478bd9Sstevel@tonic-gate /*  [10]  */	TNSZ("movups",XMMO,16),	TNSZ("movups",XMMOS,16),TNSZ("movlps",XMMO,8),	TNSZ("movlps",XMMOS,8),
8137c478bd9Sstevel@tonic-gate /*  [14]  */	TNSZ("unpcklps",XMMO,16),TNSZ("unpckhps",XMMO,16),TNSZ("movhps",XMMOM,8),TNSZ("movhps",XMMOMS,8),
8147c478bd9Sstevel@tonic-gate /*  [18]  */	IND(dis_op0F18),	INVALID,		INVALID,		INVALID,
8157c478bd9Sstevel@tonic-gate /*  [1C]  */	INVALID,		INVALID,		INVALID,		INVALID,
8167c478bd9Sstevel@tonic-gate }, {
8177c478bd9Sstevel@tonic-gate /*  [20]  */	TSy("mov",SREG),	TSy("mov",SREG),	TSy("mov",SREG),	TSy("mov",SREG),
8187c478bd9Sstevel@tonic-gate /*  [24]  */	TSx("mov",SREG),	INVALID,		TSx("mov",SREG),	INVALID,
8197c478bd9Sstevel@tonic-gate /*  [28]  */	TNSZ("movaps",XMMO,16),	TNSZ("movaps",XMMOS,16),TNSZ("cvtpi2ps",XMMOMX,8),TNSZ("movntps",XMMOS,16),
8207c478bd9Sstevel@tonic-gate /*  [2C]  */	TNSZ("cvttps2pi",XMMOXMM,8),TNSZ("cvtps2pi",XMMOXMM,8),TNSZ("ucomiss",XMMO,4),TNSZ("comiss",XMMO,4),
8217c478bd9Sstevel@tonic-gate }, {
8227c478bd9Sstevel@tonic-gate /*  [30]  */	TNS("wrmsr",NORM),	TNS("rdtsc",NORM),	TNS("rdmsr",NORM),	TNS("rdpmc",NORM),
8237c478bd9Sstevel@tonic-gate /*  [34]  */	TNSx("sysenter",NORM),	TNSx("sysexit",NORM),	INVALID,		INVALID,
8247c478bd9Sstevel@tonic-gate /*  [38]  */	INVALID,		INVALID,		INVALID,		INVALID,
8257c478bd9Sstevel@tonic-gate /*  [3C]  */	INVALID,		INVALID,		INVALID,		INVALID,
8267c478bd9Sstevel@tonic-gate }, {
8277c478bd9Sstevel@tonic-gate /*  [40]  */	TS("cmovx.o",MR),	TS("cmovx.no",MR),	TS("cmovx.b",MR),	TS("cmovx.ae",MR),
8287c478bd9Sstevel@tonic-gate /*  [44]  */	TS("cmovx.e",MR),	TS("cmovx.ne",MR),	TS("cmovx.be",MR),	TS("cmovx.a",MR),
8297c478bd9Sstevel@tonic-gate /*  [48]  */	TS("cmovx.s",MR),	TS("cmovx.ns",MR),	TS("cmovx.pe",MR),	TS("cmovx.po",MR),
8307c478bd9Sstevel@tonic-gate /*  [4C]  */	TS("cmovx.l",MR),	TS("cmovx.ge",MR),	TS("cmovx.le",MR),	TS("cmovx.g",MR),
8317c478bd9Sstevel@tonic-gate }, {
8327c478bd9Sstevel@tonic-gate /*  [50]  */	TNS("movmskps",XMMOX3),	TNSZ("sqrtps",XMMO,16),	TNSZ("rsqrtps",XMMO,16),TNSZ("rcpps",XMMO,16),
8337c478bd9Sstevel@tonic-gate /*  [54]  */	TNSZ("andps",XMMO,16),	TNSZ("andnps",XMMO,16),	TNSZ("orps",XMMO,16),	TNSZ("xorps",XMMO,16),
8347c478bd9Sstevel@tonic-gate /*  [58]  */	TNSZ("addps",XMMO,16),	TNSZ("mulps",XMMO,16),	TNSZ("cvtps2pd",XMMO,8),TNSZ("cvtdq2ps",XMMO,16),
8357c478bd9Sstevel@tonic-gate /*  [5C]  */	TNSZ("subps",XMMO,16),	TNSZ("minps",XMMO,16),	TNSZ("divps",XMMO,16),	TNSZ("maxps",XMMO,16),
8367c478bd9Sstevel@tonic-gate }, {
8377c478bd9Sstevel@tonic-gate /*  [60]  */	TNSZ("punpcklbw",MMO,4),TNSZ("punpcklwd",MMO,4),TNSZ("punpckldq",MMO,4),TNSZ("packsswb",MMO,8),
8387c478bd9Sstevel@tonic-gate /*  [64]  */	TNSZ("pcmpgtb",MMO,8),	TNSZ("pcmpgtw",MMO,8),	TNSZ("pcmpgtd",MMO,8),	TNSZ("packuswb",MMO,8),
8397c478bd9Sstevel@tonic-gate /*  [68]  */	TNSZ("punpckhbw",MMO,8),TNSZ("punpckhwd",MMO,8),TNSZ("punpckhdq",MMO,8),TNSZ("packssdw",MMO,8),
8407c478bd9Sstevel@tonic-gate /*  [6C]  */	TNSZ("INVALID",MMO,0),	TNSZ("INVALID",MMO,0),	TNSZ("movd",MMO,4),	TNSZ("movq",MMO,8),
8417c478bd9Sstevel@tonic-gate }, {
8427c478bd9Sstevel@tonic-gate /*  [70]  */	TNSZ("pshufw",MMOPM,8),	TNS("psrXXX",MR),	TNS("psrXXX",MR),	TNS("psrXXX",MR),
8437c478bd9Sstevel@tonic-gate /*  [74]  */	TNSZ("pcmpeqb",MMO,8),	TNSZ("pcmpeqw",MMO,8),	TNSZ("pcmpeqd",MMO,8),	TNS("emms",NORM),
8447c478bd9Sstevel@tonic-gate /*  [78]  */	INVALID,		INVALID,		INVALID,		INVALID,
8457c478bd9Sstevel@tonic-gate /*  [7C]  */	INVALID,		INVALID,		TNSZ("movd",MMOS,4),	TNSZ("movq",MMOS,8),
8467c478bd9Sstevel@tonic-gate }, {
8477c478bd9Sstevel@tonic-gate /*  [80]  */	TNS("jo",D),		TNS("jno",D),		TNS("jb",D),		TNS("jae",D),
8487c478bd9Sstevel@tonic-gate /*  [84]  */	TNS("je",D),		TNS("jne",D),		TNS("jbe",D),		TNS("ja",D),
8497c478bd9Sstevel@tonic-gate /*  [88]  */	TNS("js",D),		TNS("jns",D),		TNS("jp",D),		TNS("jnp",D),
8507c478bd9Sstevel@tonic-gate /*  [8C]  */	TNS("jl",D),		TNS("jge",D),		TNS("jle",D),		TNS("jg",D),
8517c478bd9Sstevel@tonic-gate }, {
8527c478bd9Sstevel@tonic-gate /*  [90]  */	TNS("seto",Mb),		TNS("setno",Mb),	TNS("setb",Mb),		TNS("setae",Mb),
8537c478bd9Sstevel@tonic-gate /*  [94]  */	TNS("sete",Mb),		TNS("setne",Mb),	TNS("setbe",Mb),	TNS("seta",Mb),
8547c478bd9Sstevel@tonic-gate /*  [98]  */	TNS("sets",Mb),		TNS("setns",Mb),	TNS("setp",Mb),		TNS("setnp",Mb),
8557c478bd9Sstevel@tonic-gate /*  [9C]  */	TNS("setl",Mb),		TNS("setge",Mb),	TNS("setle",Mb),	TNS("setg",Mb),
8567c478bd9Sstevel@tonic-gate }, {
8577c478bd9Sstevel@tonic-gate /*  [A0]  */	TSp("push",LSEG),	TSp("pop",LSEG),	TNS("cpuid",NORM),	TS("bt",RMw),
8587c478bd9Sstevel@tonic-gate /*  [A4]  */	TS("shld",DSHIFT),	TS("shld",DSHIFTcl),	INVALID,		INVALID,
8597c478bd9Sstevel@tonic-gate /*  [A8]  */	TSp("push",LSEG),	TSp("pop",LSEG),	TNS("rsm",NORM),	TS("bts",RMw),
8607c478bd9Sstevel@tonic-gate /*  [AC]  */	TS("shrd",DSHIFT),	TS("shrd",DSHIFTcl),	IND(dis_op0FAE),	TS("imul",MRw),
8617c478bd9Sstevel@tonic-gate }, {
8627c478bd9Sstevel@tonic-gate /*  [B0]  */	TNS("cmpxchgb",RMw),	TS("cmpxchg",RMw),	TS("lss",MR),		TS("btr",RMw),
8637c478bd9Sstevel@tonic-gate /*  [B4]  */	TS("lfs",MR),		TS("lgs",MR),		TS("movzb",MOVZ),	TNS("movzwl",MOVZ),
8647c478bd9Sstevel@tonic-gate /*  [B8]  */	INVALID,		INVALID,		IND(dis_op0FBA),	TS("btc",RMw),
8657c478bd9Sstevel@tonic-gate /*  [BC]  */	TS("bsf",MRw),		TS("bsr",MRw),		TS("movsb",MOVZ),	TNS("movswl",MOVZ),
8667c478bd9Sstevel@tonic-gate }, {
8677c478bd9Sstevel@tonic-gate /*  [C0]  */	TNS("xaddb",XADDB),	TS("xadd",RMw),		TNSZ("cmpps",XMMOPM,16),TNS("movnti",RM),
8687c478bd9Sstevel@tonic-gate /*  [C4]  */	TNSZ("pinsrw",MMOPRM,2),TNS("pextrw",MMO3P), 	TNSZ("shufps",XMMOPM,16),IND(dis_op0FC7),
8697c478bd9Sstevel@tonic-gate /*  [C8]  */	INVALID,		INVALID,		INVALID,		INVALID,
8707c478bd9Sstevel@tonic-gate /*  [CC]  */	INVALID,		INVALID,		INVALID,		INVALID,
8717c478bd9Sstevel@tonic-gate }, {
8727c478bd9Sstevel@tonic-gate /*  [D0]  */	INVALID,		TNSZ("psrlw",MMO,8),	TNSZ("psrld",MMO,8),	TNSZ("psrlq",MMO,8),
8737c478bd9Sstevel@tonic-gate /*  [D4]  */	TNSZ("paddq",MMO,8),	TNSZ("pmullw",MMO,8),	TNSZ("INVALID",MMO,0),	TNS("pmovmskb",MMOM3),
8747c478bd9Sstevel@tonic-gate /*  [D8]  */	TNSZ("psubusb",MMO,8),	TNSZ("psubusw",MMO,8),	TNSZ("pminub",MMO,8),	TNSZ("pand",MMO,8),
8757c478bd9Sstevel@tonic-gate /*  [DC]  */	TNSZ("paddusb",MMO,8),	TNSZ("paddusw",MMO,8),	TNSZ("pmaxub",MMO,8),	TNSZ("pandn",MMO,8),
8767c478bd9Sstevel@tonic-gate }, {
8777c478bd9Sstevel@tonic-gate /*  [E0]  */	TNSZ("pavgb",MMO,8),	TNSZ("psraw",MMO,8),	TNSZ("psrad",MMO,8),	TNSZ("pavgw",MMO,8),
8787c478bd9Sstevel@tonic-gate /*  [E4]  */	TNSZ("pmulhuw",MMO,8),	TNSZ("pmulhw",MMO,8),	TNS("INVALID",XMMO),	TNSZ("movntq",MMOMS,8),
8797c478bd9Sstevel@tonic-gate /*  [E8]  */	TNSZ("psubsb",MMO,8),	TNSZ("psubsw",MMO,8),	TNSZ("pminsw",MMO,8),	TNSZ("por",MMO,8),
8807c478bd9Sstevel@tonic-gate /*  [EC]  */	TNSZ("paddsb",MMO,8),	TNSZ("paddsw",MMO,8),	TNSZ("pmaxsw",MMO,8),	TNSZ("pxor",MMO,8),
8817c478bd9Sstevel@tonic-gate }, {
8827c478bd9Sstevel@tonic-gate /*  [F0]  */	INVALID,		TNSZ("psllw",MMO,8),	TNSZ("pslld",MMO,8),	TNSZ("psllq",MMO,8),
8837c478bd9Sstevel@tonic-gate /*  [F4]  */	TNSZ("pmuludq",MMO,8),	TNSZ("pmaddwd",MMO,8),	TNSZ("psadbw",MMO,8),	TNSZ("maskmovq",MMOIMPL,8),
8847c478bd9Sstevel@tonic-gate /*  [F8]  */	TNSZ("psubb",MMO,8),	TNSZ("psubw",MMO,8),	TNSZ("psubd",MMO,8),	TNSZ("psubq",MMO,8),
8857c478bd9Sstevel@tonic-gate /*  [FC]  */	TNSZ("paddb",MMO,8),	TNSZ("paddw",MMO,8),	TNSZ("paddd",MMO,8),	INVALID,
8867c478bd9Sstevel@tonic-gate } };
8877c478bd9Sstevel@tonic-gate 
8887c478bd9Sstevel@tonic-gate 
8897c478bd9Sstevel@tonic-gate /*
8907c478bd9Sstevel@tonic-gate  *	Decode table for 0x80 opcodes
8917c478bd9Sstevel@tonic-gate  */
8927c478bd9Sstevel@tonic-gate 
8937c478bd9Sstevel@tonic-gate const instable_t dis_op80[8] = {
8947c478bd9Sstevel@tonic-gate 
8957c478bd9Sstevel@tonic-gate /*  [0]  */	TNS("addb",IMlw),	TNS("orb",IMw),		TNS("adcb",IMlw),	TNS("sbbb",IMlw),
8967c478bd9Sstevel@tonic-gate /*  [4]  */	TNS("andb",IMw),	TNS("subb",IMlw),	TNS("xorb",IMw),	TNS("cmpb",IMlw),
8977c478bd9Sstevel@tonic-gate };
8987c478bd9Sstevel@tonic-gate 
8997c478bd9Sstevel@tonic-gate 
9007c478bd9Sstevel@tonic-gate /*
9017c478bd9Sstevel@tonic-gate  *	Decode table for 0x81 opcodes.
9027c478bd9Sstevel@tonic-gate  */
9037c478bd9Sstevel@tonic-gate 
9047c478bd9Sstevel@tonic-gate const instable_t dis_op81[8] = {
9057c478bd9Sstevel@tonic-gate 
9067c478bd9Sstevel@tonic-gate /*  [0]  */	TS("add",IMlw),		TS("or",IMw),		TS("adc",IMlw),		TS("sbb",IMlw),
9077c478bd9Sstevel@tonic-gate /*  [4]  */	TS("and",IMw),		TS("sub",IMlw),		TS("xor",IMw),		TS("cmp",IMlw),
9087c478bd9Sstevel@tonic-gate };
9097c478bd9Sstevel@tonic-gate 
9107c478bd9Sstevel@tonic-gate 
9117c478bd9Sstevel@tonic-gate /*
9127c478bd9Sstevel@tonic-gate  *	Decode table for 0x82 opcodes.
9137c478bd9Sstevel@tonic-gate  */
9147c478bd9Sstevel@tonic-gate 
9157c478bd9Sstevel@tonic-gate const instable_t dis_op82[8] = {
9167c478bd9Sstevel@tonic-gate 
9177c478bd9Sstevel@tonic-gate /*  [0]  */	TNSx("addb",IMlw),	TNSx("orb",IMlw),	TNSx("adcb",IMlw),	TNSx("sbbb",IMlw),
9187c478bd9Sstevel@tonic-gate /*  [4]  */	TNSx("andb",IMlw),	TNSx("subb",IMlw),	TNSx("xorb",IMlw),	TNSx("cmpb",IMlw),
9197c478bd9Sstevel@tonic-gate };
9207c478bd9Sstevel@tonic-gate /*
9217c478bd9Sstevel@tonic-gate  *	Decode table for 0x83 opcodes.
9227c478bd9Sstevel@tonic-gate  */
9237c478bd9Sstevel@tonic-gate 
9247c478bd9Sstevel@tonic-gate const instable_t dis_op83[8] = {
9257c478bd9Sstevel@tonic-gate 
9267c478bd9Sstevel@tonic-gate /*  [0]  */	TS("add",IMlw),		TS("or",IMlw),		TS("adc",IMlw),		TS("sbb",IMlw),
9277c478bd9Sstevel@tonic-gate /*  [4]  */	TS("and",IMlw),		TS("sub",IMlw),		TS("xor",IMlw),		TS("cmp",IMlw),
9287c478bd9Sstevel@tonic-gate };
9297c478bd9Sstevel@tonic-gate 
9307c478bd9Sstevel@tonic-gate /*
9317c478bd9Sstevel@tonic-gate  *	Decode table for 0xC0 opcodes.
9327c478bd9Sstevel@tonic-gate  */
9337c478bd9Sstevel@tonic-gate 
9347c478bd9Sstevel@tonic-gate const instable_t dis_opC0[8] = {
9357c478bd9Sstevel@tonic-gate 
9367c478bd9Sstevel@tonic-gate /*  [0]  */	TNS("rolb",MvI),	TNS("rorb",MvI),	TNS("rclb",MvI),	TNS("rcrb",MvI),
9377c478bd9Sstevel@tonic-gate /*  [4]  */	TNS("shlb",MvI),	TNS("shrb",MvI),	INVALID,		TNS("sarb",MvI),
9387c478bd9Sstevel@tonic-gate };
9397c478bd9Sstevel@tonic-gate 
9407c478bd9Sstevel@tonic-gate /*
9417c478bd9Sstevel@tonic-gate  *	Decode table for 0xD0 opcodes.
9427c478bd9Sstevel@tonic-gate  */
9437c478bd9Sstevel@tonic-gate 
9447c478bd9Sstevel@tonic-gate const instable_t dis_opD0[8] = {
9457c478bd9Sstevel@tonic-gate 
9467c478bd9Sstevel@tonic-gate /*  [0]  */	TNS("rolb",Mv),		TNS("rorb",Mv),		TNS("rclb",Mv),		TNS("rcrb",Mv),
9477c478bd9Sstevel@tonic-gate /*  [4]  */	TNS("shlb",Mv),		TNS("shrb",Mv),		TNS("salb",Mv),		TNS("sarb",Mv),
9487c478bd9Sstevel@tonic-gate };
9497c478bd9Sstevel@tonic-gate 
9507c478bd9Sstevel@tonic-gate /*
9517c478bd9Sstevel@tonic-gate  *	Decode table for 0xC1 opcodes.
9527c478bd9Sstevel@tonic-gate  *	186 instruction set
9537c478bd9Sstevel@tonic-gate  */
9547c478bd9Sstevel@tonic-gate 
9557c478bd9Sstevel@tonic-gate const instable_t dis_opC1[8] = {
9567c478bd9Sstevel@tonic-gate 
9577c478bd9Sstevel@tonic-gate /*  [0]  */	TS("rol",MvI),		TS("ror",MvI),		TS("rcl",MvI),		TS("rcr",MvI),
9587c478bd9Sstevel@tonic-gate /*  [4]  */	TS("shl",MvI),		TS("shr",MvI),		TS("sal",MvI),		TS("sar",MvI),
9597c478bd9Sstevel@tonic-gate };
9607c478bd9Sstevel@tonic-gate 
9617c478bd9Sstevel@tonic-gate /*
9627c478bd9Sstevel@tonic-gate  *	Decode table for 0xD1 opcodes.
9637c478bd9Sstevel@tonic-gate  */
9647c478bd9Sstevel@tonic-gate 
9657c478bd9Sstevel@tonic-gate const instable_t dis_opD1[8] = {
9667c478bd9Sstevel@tonic-gate 
9677c478bd9Sstevel@tonic-gate /*  [0]  */	TS("rol",Mv),		TS("ror",Mv),		TS("rcl",Mv),		TS("rcr",Mv),
9687c478bd9Sstevel@tonic-gate /*  [4]  */	TS("shl",Mv),		TS("shr",Mv),		TS("sal",Mv),		TS("sar",Mv),
9697c478bd9Sstevel@tonic-gate };
9707c478bd9Sstevel@tonic-gate 
9717c478bd9Sstevel@tonic-gate 
9727c478bd9Sstevel@tonic-gate /*
9737c478bd9Sstevel@tonic-gate  *	Decode table for 0xD2 opcodes.
9747c478bd9Sstevel@tonic-gate  */
9757c478bd9Sstevel@tonic-gate 
9767c478bd9Sstevel@tonic-gate const instable_t dis_opD2[8] = {
9777c478bd9Sstevel@tonic-gate 
9787c478bd9Sstevel@tonic-gate /*  [0]  */	TNS("rolb",Mv),		TNS("rorb",Mv),		TNS("rclb",Mv),		TNS("rcrb",Mv),
9797c478bd9Sstevel@tonic-gate /*  [4]  */	TNS("shlb",Mv),		TNS("shrb",Mv),		TNS("salb",Mv),		TNS("sarb",Mv),
9807c478bd9Sstevel@tonic-gate };
9817c478bd9Sstevel@tonic-gate /*
9827c478bd9Sstevel@tonic-gate  *	Decode table for 0xD3 opcodes.
9837c478bd9Sstevel@tonic-gate  */
9847c478bd9Sstevel@tonic-gate 
9857c478bd9Sstevel@tonic-gate const instable_t dis_opD3[8] = {
9867c478bd9Sstevel@tonic-gate 
9877c478bd9Sstevel@tonic-gate /*  [0]  */	TS("rol",Mv),		TS("ror",Mv),		TS("rcl",Mv),		TS("rcr",Mv),
9887c478bd9Sstevel@tonic-gate /*  [4]  */	TS("shl",Mv),		TS("shr",Mv),		TS("salb",Mv),		TS("sar",Mv),
9897c478bd9Sstevel@tonic-gate };
9907c478bd9Sstevel@tonic-gate 
9917c478bd9Sstevel@tonic-gate 
9927c478bd9Sstevel@tonic-gate /*
9937c478bd9Sstevel@tonic-gate  *	Decode table for 0xF6 opcodes.
9947c478bd9Sstevel@tonic-gate  */
9957c478bd9Sstevel@tonic-gate 
9967c478bd9Sstevel@tonic-gate const instable_t dis_opF6[8] = {
9977c478bd9Sstevel@tonic-gate 
9987c478bd9Sstevel@tonic-gate /*  [0]  */	TNS("testb",IMw),	TNS("testb",IMw),	TNS("notb",Mw),		TNS("negb",Mw),
9997c478bd9Sstevel@tonic-gate /*  [4]  */	TNS("mulb",MA),		TNS("imulb",MA),	TNS("divb",MA),		TNS("idivb",MA),
10007c478bd9Sstevel@tonic-gate };
10017c478bd9Sstevel@tonic-gate 
10027c478bd9Sstevel@tonic-gate 
10037c478bd9Sstevel@tonic-gate /*
10047c478bd9Sstevel@tonic-gate  *	Decode table for 0xF7 opcodes.
10057c478bd9Sstevel@tonic-gate  */
10067c478bd9Sstevel@tonic-gate 
10077c478bd9Sstevel@tonic-gate const instable_t dis_opF7[8] = {
10087c478bd9Sstevel@tonic-gate 
10097c478bd9Sstevel@tonic-gate /*  [0]  */	TS("test",IMw),		TS("test",IMw),		TS("not",Mw),		TS("neg",Mw),
10107c478bd9Sstevel@tonic-gate /*  [4]  */	TS("mul",MA),		TS("imul",MA),		TS("div",MA),		TS("idiv",MA),
10117c478bd9Sstevel@tonic-gate };
10127c478bd9Sstevel@tonic-gate 
10137c478bd9Sstevel@tonic-gate 
10147c478bd9Sstevel@tonic-gate /*
10157c478bd9Sstevel@tonic-gate  *	Decode table for 0xFE opcodes.
10167c478bd9Sstevel@tonic-gate  */
10177c478bd9Sstevel@tonic-gate 
10187c478bd9Sstevel@tonic-gate const instable_t dis_opFE[8] = {
10197c478bd9Sstevel@tonic-gate 
10207c478bd9Sstevel@tonic-gate /*  [0]  */	TNS("incb",Mw),		TNS("decb",Mw),		INVALID,		INVALID,
10217c478bd9Sstevel@tonic-gate /*  [4]  */	INVALID,		INVALID,		INVALID,		INVALID,
10227c478bd9Sstevel@tonic-gate };
10237c478bd9Sstevel@tonic-gate /*
10247c478bd9Sstevel@tonic-gate  *	Decode table for 0xFF opcodes.
10257c478bd9Sstevel@tonic-gate  */
10267c478bd9Sstevel@tonic-gate 
10277c478bd9Sstevel@tonic-gate const instable_t dis_opFF[8] = {
10287c478bd9Sstevel@tonic-gate 
10297c478bd9Sstevel@tonic-gate /*  [0]  */	TS("inc",Mw),		TS("dec",Mw),		TNSyp("call",INM),	TNS("lcall",INM),
10307c478bd9Sstevel@tonic-gate /*  [4]  */	TNSy("jmp",INM),	TNS("ljmp",INM),	TSp("push",M),		INVALID,
10317c478bd9Sstevel@tonic-gate };
10327c478bd9Sstevel@tonic-gate 
10337c478bd9Sstevel@tonic-gate /* for 287 instructions, which are a mess to decode */
10347c478bd9Sstevel@tonic-gate 
10357c478bd9Sstevel@tonic-gate const instable_t dis_opFP1n2[8][8] = {
10367c478bd9Sstevel@tonic-gate {
10377c478bd9Sstevel@tonic-gate /* bit pattern:	1101 1xxx MODxx xR/M */
10387c478bd9Sstevel@tonic-gate /*  [0,0] */	TNS("fadds",M),		TNS("fmuls",M),		TNS("fcoms",M),		TNS("fcomps",M),
10397c478bd9Sstevel@tonic-gate /*  [0,4] */	TNS("fsubs",M),		TNS("fsubrs",M),	TNS("fdivs",M),		TNS("fdivrs",M),
10407c478bd9Sstevel@tonic-gate }, {
10417c478bd9Sstevel@tonic-gate /*  [1,0]  */	TNS("flds",M),		INVALID,		TNS("fsts",M),		TNS("fstps",M),
10427c478bd9Sstevel@tonic-gate /*  [1,4]  */	TNSZ("fldenv",M,28),	TNSZ("fldcw",M,2),	TNSZ("fnstenv",M,28),	TNSZ("fnstcw",M,2),
10437c478bd9Sstevel@tonic-gate }, {
10447c478bd9Sstevel@tonic-gate /*  [2,0]  */	TNS("fiaddl",M),	TNS("fimull",M),	TNS("ficoml",M),	TNS("ficompl",M),
10457c478bd9Sstevel@tonic-gate /*  [2,4]  */	TNS("fisubl",M),	TNS("fisubrl",M),	TNS("fidivl",M),	TNS("fidivrl",M),
10467c478bd9Sstevel@tonic-gate }, {
10477c478bd9Sstevel@tonic-gate /*  [3,0]  */	TNS("fildl",M),		INVALID,		TNS("fistl",M),		TNS("fistpl",M),
10487c478bd9Sstevel@tonic-gate /*  [3,4]  */	INVALID,		TNSZ("fldt",M,10),	INVALID,		TNSZ("fstpt",M,10),
10497c478bd9Sstevel@tonic-gate }, {
10507c478bd9Sstevel@tonic-gate /*  [4,0]  */	TNSZ("faddl",M,8),	TNSZ("fmull",M,8),	TNSZ("fcoml",M,8),	TNSZ("fcompl",M,8),
10517c478bd9Sstevel@tonic-gate /*  [4,1]  */	TNSZ("fsubl",M,8),	TNSZ("fsubrl",M,8),	TNSZ("fdivl",M,8),	TNSZ("fdivrl",M,8),
10527c478bd9Sstevel@tonic-gate }, {
10537c478bd9Sstevel@tonic-gate /*  [5,0]  */	TNSZ("fldl",M,8),	INVALID,		TNSZ("fstl",M,8),	TNSZ("fstpl",M,8),
10547c478bd9Sstevel@tonic-gate /*  [5,4]  */	TNSZ("frstor",M,108),	INVALID,		TNSZ("fnsave",M,108),	TNSZ("fnstsw",M,2),
10557c478bd9Sstevel@tonic-gate }, {
10567c478bd9Sstevel@tonic-gate /*  [6,0]  */	TNSZ("fiadd",M,2),	TNSZ("fimul",M,2),	TNSZ("ficom",M,2),	TNSZ("ficomp",M,2),
10577c478bd9Sstevel@tonic-gate /*  [6,4]  */	TNSZ("fisub",M,2),	TNSZ("fisubr",M,2),	TNSZ("fidiv",M,2),	TNSZ("fidivr",M,2),
10587c478bd9Sstevel@tonic-gate }, {
10597c478bd9Sstevel@tonic-gate /*  [7,0]  */	TNSZ("fild",M,2),	INVALID,		TNSZ("fist",M,2),	TNSZ("fistp",M,2),
10607c478bd9Sstevel@tonic-gate /*  [7,4]  */	TNSZ("fbld",M,10),	TNSZ("fildll",M,8),	TNSZ("fbstp",M,10),	TNSZ("fistpll",M,8),
10617c478bd9Sstevel@tonic-gate } };
10627c478bd9Sstevel@tonic-gate 
10637c478bd9Sstevel@tonic-gate const instable_t dis_opFP3[8][8] = {
10647c478bd9Sstevel@tonic-gate {
10657c478bd9Sstevel@tonic-gate /* bit  pattern:	1101 1xxx 11xx xREG */
10667c478bd9Sstevel@tonic-gate /*  [0,0]  */	TNS("fadd",FF),		TNS("fmul",FF),		TNS("fcom",F),		TNS("fcomp",F),
10677c478bd9Sstevel@tonic-gate /*  [0,4]  */	TNS("fsub",FF),		TNS("fsubr",FF),	TNS("fdiv",FF),		TNS("fdivr",FF),
10687c478bd9Sstevel@tonic-gate }, {
10697c478bd9Sstevel@tonic-gate /*  [1,0]  */	TNS("fld",F),		TNS("fxch",F),		TNS("fnop",NORM),	TNS("fstp",F),
10707c478bd9Sstevel@tonic-gate /*  [1,4]  */	INVALID,		INVALID,		INVALID,		INVALID,
10717c478bd9Sstevel@tonic-gate }, {
10727c478bd9Sstevel@tonic-gate /*  [2,0]  */	INVALID,		INVALID,		INVALID,		INVALID,
10737c478bd9Sstevel@tonic-gate /*  [2,4]  */	INVALID,		TNS("fucompp",NORM),	INVALID,		INVALID,
10747c478bd9Sstevel@tonic-gate }, {
10757c478bd9Sstevel@tonic-gate /*  [3,0]  */	INVALID,		INVALID,		INVALID,		INVALID,
10767c478bd9Sstevel@tonic-gate /*  [3,4]  */	INVALID,		INVALID,		INVALID,		INVALID,
10777c478bd9Sstevel@tonic-gate }, {
10787c478bd9Sstevel@tonic-gate /*  [4,0]  */	TNS("fadd",FF),		TNS("fmul",FF),		TNS("fcom",F),		TNS("fcomp",F),
10797c478bd9Sstevel@tonic-gate /*  [4,4]  */	TNS("fsub",FF),		TNS("fsubr",FF),	TNS("fdiv",FF),		TNS("fdivr",FF),
10807c478bd9Sstevel@tonic-gate }, {
10817c478bd9Sstevel@tonic-gate /*  [5,0]  */	TNS("ffree",F),		TNS("fxch",F),		TNS("fst",F),		TNS("fstp",F),
10827c478bd9Sstevel@tonic-gate /*  [5,4]  */	TNS("fucom",F),		TNS("fucomp",F),	INVALID,		INVALID,
10837c478bd9Sstevel@tonic-gate }, {
10847c478bd9Sstevel@tonic-gate /*  [6,0]  */	TNS("faddp",FF),	TNS("fmulp",FF),	TNS("fcomp",F),		TNS("fcompp",NORM),
10857c478bd9Sstevel@tonic-gate /*  [6,4]  */	TNS("fsubp",FF),	TNS("fsubrp",FF),	TNS("fdivp",FF),	TNS("fdivrp",FF),
10867c478bd9Sstevel@tonic-gate }, {
10877c478bd9Sstevel@tonic-gate /*  [7,0]  */	TNS("ffree",F),		TNS("fxch",F),		TNS("fstp",F),		TNS("fstp",F),
10887c478bd9Sstevel@tonic-gate /*  [7,4]  */	TNS("fnstsw",M),	TNS("fucomip",FFC),	TNS("fcomip",FFC),	INVALID,
10897c478bd9Sstevel@tonic-gate } };
10907c478bd9Sstevel@tonic-gate 
10917c478bd9Sstevel@tonic-gate const instable_t dis_opFP4[4][8] = {
10927c478bd9Sstevel@tonic-gate {
10937c478bd9Sstevel@tonic-gate /* bit pattern:	1101 1001 111x xxxx */
10947c478bd9Sstevel@tonic-gate /*  [0,0]  */	TNS("fchs",NORM),	TNS("fabs",NORM),	INVALID,		INVALID,
10957c478bd9Sstevel@tonic-gate /*  [0,4]  */	TNS("ftst",NORM),	TNS("fxam",NORM),	TNS("ftstp",NORM),	INVALID,
10967c478bd9Sstevel@tonic-gate }, {
10977c478bd9Sstevel@tonic-gate /*  [1,0]  */	TNS("fld1",NORM),	TNS("fldl2t",NORM),	TNS("fldl2e",NORM),	TNS("fldpi",NORM),
10987c478bd9Sstevel@tonic-gate /*  [1,4]  */	TNS("fldlg2",NORM),	TNS("fldln2",NORM),	TNS("fldz",NORM),	INVALID,
10997c478bd9Sstevel@tonic-gate }, {
11007c478bd9Sstevel@tonic-gate /*  [2,0]  */	TNS("f2xm1",NORM),	TNS("fyl2x",NORM),	TNS("fptan",NORM),	TNS("fpatan",NORM),
11017c478bd9Sstevel@tonic-gate /*  [2,4]  */	TNS("fxtract",NORM),	TNS("fprem1",NORM),	TNS("fdecstp",NORM),	TNS("fincstp",NORM),
11027c478bd9Sstevel@tonic-gate }, {
11037c478bd9Sstevel@tonic-gate /*  [3,0]  */	TNS("fprem",NORM),	TNS("fyl2xp1",NORM),	TNS("fsqrt",NORM),	TNS("fsincos",NORM),
11047c478bd9Sstevel@tonic-gate /*  [3,4]  */	TNS("frndint",NORM),	TNS("fscale",NORM),	TNS("fsin",NORM),	TNS("fcos",NORM),
11057c478bd9Sstevel@tonic-gate } };
11067c478bd9Sstevel@tonic-gate 
11077c478bd9Sstevel@tonic-gate const instable_t dis_opFP5[8] = {
11087c478bd9Sstevel@tonic-gate /* bit pattern:	1101 1011 111x xxxx */
11097c478bd9Sstevel@tonic-gate /*  [0]  */	TNS("feni",NORM),	TNS("fdisi",NORM),	TNS("fnclex",NORM),	TNS("fninit",NORM),
11107c478bd9Sstevel@tonic-gate /*  [4]  */	TNS("fsetpm",NORM),	TNS("frstpm",NORM),	INVALID,		INVALID,
11117c478bd9Sstevel@tonic-gate };
11127c478bd9Sstevel@tonic-gate 
11137c478bd9Sstevel@tonic-gate const instable_t dis_opFP6[8] = {
11147c478bd9Sstevel@tonic-gate /* bit pattern:	1101 1011 11yy yxxx */
11157c478bd9Sstevel@tonic-gate /*  [00]  */	TNS("fcmov.nb",FF),	TNS("fcmov.ne",FF),	TNS("fcmov.nbe",FF),	TNS("fcmov.nu",FF),
11167c478bd9Sstevel@tonic-gate /*  [04]  */	INVALID,		TNS("fucomi",F),	TNS("fcomi",F),		INVALID,
11177c478bd9Sstevel@tonic-gate };
11187c478bd9Sstevel@tonic-gate 
11197c478bd9Sstevel@tonic-gate const instable_t dis_opFP7[8] = {
11207c478bd9Sstevel@tonic-gate /* bit pattern:	1101 1010 11yy yxxx */
11217c478bd9Sstevel@tonic-gate /*  [00]  */	TNS("fcmov.b",FF),	TNS("fcmov.e",FF),	TNS("fcmov.be",FF),	TNS("fcmov.u",FF),
11227c478bd9Sstevel@tonic-gate /*  [04]  */	INVALID,		INVALID,		INVALID,		INVALID,
11237c478bd9Sstevel@tonic-gate };
11247c478bd9Sstevel@tonic-gate 
11257c478bd9Sstevel@tonic-gate /*
11267c478bd9Sstevel@tonic-gate  *	Main decode table for the op codes.  The first two nibbles
11277c478bd9Sstevel@tonic-gate  *	will be used as an index into the table.  If there is a
11287c478bd9Sstevel@tonic-gate  *	a need to further decode an instruction, the array to be
11297c478bd9Sstevel@tonic-gate  *	referenced is indicated with the other two entries being
11307c478bd9Sstevel@tonic-gate  *	empty.
11317c478bd9Sstevel@tonic-gate  */
11327c478bd9Sstevel@tonic-gate 
11337c478bd9Sstevel@tonic-gate const instable_t dis_distable[16][16] = {
11347c478bd9Sstevel@tonic-gate {
11357c478bd9Sstevel@tonic-gate /* [0,0] */	TNS("addb",RMw),	TS("add",RMw),		TNS("addb",MRw),	TS("add",MRw),
11367c478bd9Sstevel@tonic-gate /* [0,4] */	TNS("addb",IA),		TS("add",IA),		TSx("push",SEG),	TSx("pop",SEG),
11377c478bd9Sstevel@tonic-gate /* [0,8] */	TNS("orb",RMw),		TS("or",RMw),		TNS("orb",MRw),		TS("or",MRw),
11387c478bd9Sstevel@tonic-gate /* [0,C] */	TNS("orb",IA),		TS("or",IA),		TSx("push",SEG),	IND(dis_op0F),
11397c478bd9Sstevel@tonic-gate }, {
11407c478bd9Sstevel@tonic-gate /* [1,0] */	TNS("adcb",RMw),	TS("adc",RMw),		TNS("adcb",MRw),	TS("adc",MRw),
11417c478bd9Sstevel@tonic-gate /* [1,4] */	TNS("adcb",IA),		TS("adc",IA),		TSx("push",SEG),	TSx("pop",SEG),
11427c478bd9Sstevel@tonic-gate /* [1,8] */	TNS("sbbb",RMw),	TS("sbb",RMw),		TNS("sbbb",MRw),	TS("sbb",MRw),
11437c478bd9Sstevel@tonic-gate /* [1,C] */	TNS("sbbb",IA),		TS("sbb",IA),		TSx("push",SEG),	TSx("pop",SEG),
11447c478bd9Sstevel@tonic-gate }, {
11457c478bd9Sstevel@tonic-gate /* [2,0] */	TNS("andb",RMw),	TS("and",RMw),		TNS("andb",MRw),	TS("and",MRw),
11467c478bd9Sstevel@tonic-gate /* [2,4] */	TNS("andb",IA),		TS("and",IA),		TNSx("%es:",OVERRIDE),	TNSx("daa",NORM),
11477c478bd9Sstevel@tonic-gate /* [2,8] */	TNS("subb",RMw),	TS("sub",RMw),		TNS("subb",MRw),	TS("sub",MRw),
11487c478bd9Sstevel@tonic-gate /* [2,C] */	TNS("subb",IA),		TS("sub",IA),		TNSx("%cs:",OVERRIDE),	TNSx("das",NORM),
11497c478bd9Sstevel@tonic-gate }, {
11507c478bd9Sstevel@tonic-gate /* [3,0] */	TNS("xorb",RMw),	TS("xor",RMw),		TNS("xorb",MRw),	TS("xor",MRw),
11517c478bd9Sstevel@tonic-gate /* [3,4] */	TNS("xorb",IA),		TS("xor",IA),		TNSx("%ss:",OVERRIDE),	TNSx("aaa",NORM),
11527c478bd9Sstevel@tonic-gate /* [3,8] */	TNS("cmpb",RMw),	TS("cmp",RMw),		TNS("cmpb",MRw),	TS("cmp",MRw),
11537c478bd9Sstevel@tonic-gate /* [3,C] */	TNS("cmpb",IA),		TS("cmp",IA),		TNSx("%ds:",OVERRIDE),	TNSx("aas",NORM),
11547c478bd9Sstevel@tonic-gate }, {
11557c478bd9Sstevel@tonic-gate /* [4,0] */	TSx("inc",R),		TSx("inc",R),		TSx("inc",R),		TSx("inc",R),
11567c478bd9Sstevel@tonic-gate /* [4,4] */	TSx("inc",R),		TSx("inc",R),		TSx("inc",R),		TSx("inc",R),
11577c478bd9Sstevel@tonic-gate /* [4,8] */	TSx("dec",R),		TSx("dec",R),		TSx("dec",R),		TSx("dec",R),
11587c478bd9Sstevel@tonic-gate /* [4,C] */	TSx("dec",R),		TSx("dec",R),		TSx("dec",R),		TSx("dec",R),
11597c478bd9Sstevel@tonic-gate }, {
11607c478bd9Sstevel@tonic-gate /* [5,0] */	TSp("push",R),		TSp("push",R),		TSp("push",R),		TSp("push",R),
11617c478bd9Sstevel@tonic-gate /* [5,4] */	TSp("push",R),		TSp("push",R),		TSp("push",R),		TSp("push",R),
11627c478bd9Sstevel@tonic-gate /* [5,8] */	TSp("pop",R),		TSp("pop",R),		TSp("pop",R),		TSp("pop",R),
11637c478bd9Sstevel@tonic-gate /* [5,C] */	TSp("pop",R),		TSp("pop",R),		TSp("pop",R),		TSp("pop",R),
11647c478bd9Sstevel@tonic-gate }, {
11657c478bd9Sstevel@tonic-gate /* [6,0] */	TSZx("pusha",IMPLMEM,28),TSZx("popa",IMPLMEM,28), TSx("bound",MR),	TNS("arpl",RMw),
11667c478bd9Sstevel@tonic-gate /* [6,4] */	TNS("%fs:",OVERRIDE),	TNS("%gs:",OVERRIDE),	TNS("data16",DM),	TNS("addr16",AM),
11677c478bd9Sstevel@tonic-gate /* [6,8] */	TSp("push",I),		TS("imul",IMUL),	TSp("push",Ib),	TS("imul",IMUL),
11687c478bd9Sstevel@tonic-gate /* [6,C] */	TNSZ("insb",IMPLMEM,1),	TSZ("ins",IMPLMEM,4),	TNSZ("outsb",IMPLMEM,1),TSZ("outs",IMPLMEM,4),
11697c478bd9Sstevel@tonic-gate }, {
11707c478bd9Sstevel@tonic-gate /* [7,0] */	TNSy("jo",BD),		TNSy("jno",BD),		TNSy("jb",BD),		TNSy("jae",BD),
11717c478bd9Sstevel@tonic-gate /* [7,4] */	TNSy("je",BD),		TNSy("jne",BD),		TNSy("jbe",BD),		TNSy("ja",BD),
11727c478bd9Sstevel@tonic-gate /* [7,8] */	TNSy("js",BD),		TNSy("jns",BD),		TNSy("jp",BD),		TNSy("jnp",BD),
11737c478bd9Sstevel@tonic-gate /* [7,C] */	TNSy("jl",BD),		TNSy("jge",BD),		TNSy("jle",BD),		TNSy("jg",BD),
11747c478bd9Sstevel@tonic-gate }, {
11757c478bd9Sstevel@tonic-gate /* [8,0] */	IND(dis_op80),		IND(dis_op81),		INDx(dis_op82),		IND(dis_op83),
11767c478bd9Sstevel@tonic-gate /* [8,4] */	TNS("testb",RMw),	TS("test",RMw),		TNS("xchgb",RMw),	TS("xchg",RMw),
11777c478bd9Sstevel@tonic-gate /* [8,8] */	TNS("movb",RMw),	TS("mov",RMw),		TNS("movb",MRw),	TS("mov",MRw),
11787c478bd9Sstevel@tonic-gate /* [8,C] */	TNS("movw",SM),		TS("lea",MR),		TNS("movw",MS),		TSp("pop",M),
11797c478bd9Sstevel@tonic-gate }, {
11807c478bd9Sstevel@tonic-gate /* [9,0] */	TNS("nop",NORM),	TS("xchg",RA),		TS("xchg",RA),		TS("xchg",RA),
11817c478bd9Sstevel@tonic-gate /* [9,4] */	TS("xchg",RA),		TS("xchg",RA),		TS("xchg",RA),		TS("xchg",RA),
11827c478bd9Sstevel@tonic-gate /* [9,8] */	TNS("cXtX",CBW),	TNS("cXtX",CWD),	TNSx("lcall",SO),	TNS("fwait",NORM),
11837c478bd9Sstevel@tonic-gate /* [9,C] */	TSZy("pushf",IMPLMEM,4),TSZy("popf",IMPLMEM,4),	TNSx("sahf",NORM),	TNSx("lahf",NORM),
11847c478bd9Sstevel@tonic-gate }, {
11857c478bd9Sstevel@tonic-gate /* [A,0] */	TNS("movb",OA),		TS("mov",OA),		TNS("movb",AO),		TS("mov",AO),
11867c478bd9Sstevel@tonic-gate /* [A,4] */	TNSZ("movsb",SD,1),	TS("movs",SD),		TNSZ("cmpsb",SD,1),	TS("cmps",SD),
11877c478bd9Sstevel@tonic-gate /* [A,8] */	TNS("testb",IA),	TS("test",IA),		TNS("stosb",AD),	TS("stos",AD),
11887c478bd9Sstevel@tonic-gate /* [A,C] */	TNS("lodsb",SA),	TS("lods",SA),		TNS("scasb",AD),	TS("scas",AD),
11897c478bd9Sstevel@tonic-gate }, {
11907c478bd9Sstevel@tonic-gate /* [B,0] */	TNS("movb",IR),		TNS("movb",IR),		TNS("movb",IR),		TNS("movb",IR),
11917c478bd9Sstevel@tonic-gate /* [B,4] */	TNS("movb",IR),		TNS("movb",IR),		TNS("movb",IR),		TNS("movb",IR),
11927c478bd9Sstevel@tonic-gate /* [B,8] */	TS("mov",IR),		TS("mov",IR),		TS("mov",IR),		TS("mov",IR),
11937c478bd9Sstevel@tonic-gate /* [B,C] */	TS("mov",IR),		TS("mov",IR),		TS("mov",IR),		TS("mov",IR),
11947c478bd9Sstevel@tonic-gate }, {
11957c478bd9Sstevel@tonic-gate /* [C,0] */	IND(dis_opC0),		IND(dis_opC1), 		TNSyp("ret",RET),	TNSyp("ret",NORM),
11967c478bd9Sstevel@tonic-gate /* [C,4] */	TNSx("les",MR),		TNSx("lds",MR),		TNS("movb",IMw),	TS("mov",IMw),
11977c478bd9Sstevel@tonic-gate /* [C,8] */	TNSyp("enter",ENTER),	TNSyp("leave",NORM),	TNS("lret",RET),	TNS("lret",NORM),
11987c478bd9Sstevel@tonic-gate /* [C,C] */	TNS("int",INT3),	TNS("int",INTx),	TNSx("into",NORM),	TNS("iret",NORM),
11997c478bd9Sstevel@tonic-gate }, {
12007c478bd9Sstevel@tonic-gate /* [D,0] */	IND(dis_opD0),		IND(dis_opD1),		IND(dis_opD2),		IND(dis_opD3),
12017c478bd9Sstevel@tonic-gate /* [D,4] */	TNSx("aam",U),		TNSx("aad",U),		TNSx("falc",NORM),	TNSZ("xlat",IMPLMEM,1),
12027c478bd9Sstevel@tonic-gate 
12037c478bd9Sstevel@tonic-gate /* 287 instructions.  Note that although the indirect field		*/
12047c478bd9Sstevel@tonic-gate /* indicates opFP1n2 for further decoding, this is not necessarily	*/
12057c478bd9Sstevel@tonic-gate /* the case since the opFP arrays are not partitioned according to key1	*/
12067c478bd9Sstevel@tonic-gate /* and key2.  opFP1n2 is given only to indicate that we haven't		*/
12077c478bd9Sstevel@tonic-gate /* finished decoding the instruction.					*/
12087c478bd9Sstevel@tonic-gate /* [D,8] */	IND(dis_opFP1n2),	IND(dis_opFP1n2),	IND(dis_opFP1n2),	IND(dis_opFP1n2),
12097c478bd9Sstevel@tonic-gate /* [D,C] */	IND(dis_opFP1n2),	IND(dis_opFP1n2),	IND(dis_opFP1n2),	IND(dis_opFP1n2),
12107c478bd9Sstevel@tonic-gate }, {
12117c478bd9Sstevel@tonic-gate /* [E,0] */	TNSy("loopnz",BD),	TNSy("loopz",BD),	TNSy("loop",BD),	TNSy("jcxz",BD),
12127c478bd9Sstevel@tonic-gate /* [E,4] */	TNS("inb",P),		TS("in",P),		TNS("outb",P),		TS("out",P),
12137c478bd9Sstevel@tonic-gate /* [E,8] */	TNSyp("call",D),	TNSy("jmp",D),		TNSx("ljmp",SO),		TNSy("jmp",BD),
12147c478bd9Sstevel@tonic-gate /* [E,C] */	TNS("inb",V),		TS("in",V),		TNS("outb",V),		TS("out",V),
12157c478bd9Sstevel@tonic-gate }, {
12167c478bd9Sstevel@tonic-gate /* [F,0] */	TNS("lock",LOCK),	TNS("icebp", NORM),	TNS("repnz",PREFIX),	TNS("repz",PREFIX),
12177c478bd9Sstevel@tonic-gate /* [F,4] */	TNS("hlt",NORM),	TNS("cmc",NORM),	IND(dis_opF6),		IND(dis_opF7),
12187c478bd9Sstevel@tonic-gate /* [F,8] */	TNS("clc",NORM),	TNS("stc",NORM),	TNS("cli",NORM),	TNS("sti",NORM),
12197c478bd9Sstevel@tonic-gate /* [F,C] */	TNS("cld",NORM),	TNS("std",NORM),	IND(dis_opFE),		IND(dis_opFF),
12207c478bd9Sstevel@tonic-gate } };
12217c478bd9Sstevel@tonic-gate 
12227c478bd9Sstevel@tonic-gate /* END CSTYLED */
12237c478bd9Sstevel@tonic-gate 
12247c478bd9Sstevel@tonic-gate /*
12257c478bd9Sstevel@tonic-gate  * common functions to decode and disassemble an x86 or amd64 instruction
12267c478bd9Sstevel@tonic-gate  */
12277c478bd9Sstevel@tonic-gate 
12287c478bd9Sstevel@tonic-gate /*
12297c478bd9Sstevel@tonic-gate  * These are the individual fields of a REX prefix. Note that a REX
12307c478bd9Sstevel@tonic-gate  * prefix with none of these set is still needed to:
12317c478bd9Sstevel@tonic-gate  *	- use the MOVSXD (sign extend 32 to 64 bits) instruction
12327c478bd9Sstevel@tonic-gate  *	- access the %sil, %dil, %bpl, %spl registers
12337c478bd9Sstevel@tonic-gate  */
12347c478bd9Sstevel@tonic-gate #define	REX_W 0x08	/* 64 bit operand size when set */
12357c478bd9Sstevel@tonic-gate #define	REX_R 0x04	/* high order bit extension of ModRM reg field */
12367c478bd9Sstevel@tonic-gate #define	REX_X 0x02	/* high order bit extension of SIB index field */
12377c478bd9Sstevel@tonic-gate #define	REX_B 0x01	/* extends ModRM r_m, SIB base, or opcode reg */
12387c478bd9Sstevel@tonic-gate 
12397c478bd9Sstevel@tonic-gate static uint_t opnd_size;	/* SIZE16, SIZE32 or SIZE64 */
12407c478bd9Sstevel@tonic-gate static uint_t addr_size;	/* SIZE16, SIZE32 or SIZE64 */
12417c478bd9Sstevel@tonic-gate 
12427c478bd9Sstevel@tonic-gate /*
12437c478bd9Sstevel@tonic-gate  * Even in 64 bit mode, usually only 4 byte immediate operands are supported.
12447c478bd9Sstevel@tonic-gate  */
12457c478bd9Sstevel@tonic-gate static int isize[] = {1, 2, 4, 4};
12467c478bd9Sstevel@tonic-gate static int isize64[] = {1, 2, 4, 8};
12477c478bd9Sstevel@tonic-gate 
12487c478bd9Sstevel@tonic-gate /*
12497c478bd9Sstevel@tonic-gate  * Just a bunch of useful macros.
12507c478bd9Sstevel@tonic-gate  */
12517c478bd9Sstevel@tonic-gate #define	WBIT(x)	(x & 0x1)		/* to get w bit	*/
12527c478bd9Sstevel@tonic-gate #define	REGNO(x) (x & 0x7)		/* to get 3 bit register */
12537c478bd9Sstevel@tonic-gate #define	VBIT(x)	((x)>>1 & 0x1)		/* to get 'v' bit */
12547c478bd9Sstevel@tonic-gate #define	OPSIZE(osize, wbit) ((wbit) ? isize[osize] : 1)
12557c478bd9Sstevel@tonic-gate #define	OPSIZE64(osize, wbit) ((wbit) ? isize64[osize] : 1)
12567c478bd9Sstevel@tonic-gate 
12577c478bd9Sstevel@tonic-gate #define	REG_ONLY 3	/* mode to indicate a register operand (not memory) */
12587c478bd9Sstevel@tonic-gate 
12597c478bd9Sstevel@tonic-gate #define	BYTE_OPND	0	/* w-bit value indicating byte register */
12607c478bd9Sstevel@tonic-gate #define	LONG_OPND	1	/* w-bit value indicating opnd_size register */
12617c478bd9Sstevel@tonic-gate #define	MM_OPND		2	/* "value" used to indicate a mmx reg */
12627c478bd9Sstevel@tonic-gate #define	XMM_OPND	3	/* "value" used to indicate a xmm reg */
12637c478bd9Sstevel@tonic-gate #define	SEG_OPND	4	/* "value" used to indicate a segment reg */
12647c478bd9Sstevel@tonic-gate #define	CONTROL_OPND	5	/* "value" used to indicate a control reg */
12657c478bd9Sstevel@tonic-gate #define	DEBUG_OPND	6	/* "value" used to indicate a debug reg */
12667c478bd9Sstevel@tonic-gate #define	TEST_OPND	7	/* "value" used to indicate a test reg */
12677c478bd9Sstevel@tonic-gate #define	WORD_OPND	8	/* w-bit value indicating word size reg */
12687c478bd9Sstevel@tonic-gate 
12697c478bd9Sstevel@tonic-gate /*
12707c478bd9Sstevel@tonic-gate  * Get the next byte and separate the op code into the high and low nibbles.
12717c478bd9Sstevel@tonic-gate  */
12727c478bd9Sstevel@tonic-gate static int
12737c478bd9Sstevel@tonic-gate dtrace_get_opcode(dis86_t *x, uint_t *high, uint_t *low)
12747c478bd9Sstevel@tonic-gate {
12757c478bd9Sstevel@tonic-gate 	int byte;
12767c478bd9Sstevel@tonic-gate 
12777c478bd9Sstevel@tonic-gate 	/*
12787c478bd9Sstevel@tonic-gate 	 * x86 instructions have a maximum length of 15 bytes.  Bail out if
12797c478bd9Sstevel@tonic-gate 	 * we try to read more.
12807c478bd9Sstevel@tonic-gate 	 */
12817c478bd9Sstevel@tonic-gate 	if (x->d86_len >= 15)
12827c478bd9Sstevel@tonic-gate 		return (x->d86_error = 1);
12837c478bd9Sstevel@tonic-gate 
12847c478bd9Sstevel@tonic-gate 	if (x->d86_error)
12857c478bd9Sstevel@tonic-gate 		return (1);
12867c478bd9Sstevel@tonic-gate 	byte = x->d86_get_byte(x->d86_data);
12877c478bd9Sstevel@tonic-gate 	if (byte < 0)
12887c478bd9Sstevel@tonic-gate 		return (x->d86_error = 1);
12897c478bd9Sstevel@tonic-gate 	x->d86_bytes[x->d86_len++] = byte;
12907c478bd9Sstevel@tonic-gate 	*low = byte & 0xf;		/* ----xxxx low 4 bits */
12917c478bd9Sstevel@tonic-gate 	*high = byte >> 4 & 0xf;	/* xxxx---- bits 7 to 4 */
12927c478bd9Sstevel@tonic-gate 	return (0);
12937c478bd9Sstevel@tonic-gate }
12947c478bd9Sstevel@tonic-gate 
12957c478bd9Sstevel@tonic-gate /*
12967c478bd9Sstevel@tonic-gate  * Get and decode an SIB (scaled index base) byte
12977c478bd9Sstevel@tonic-gate  */
12987c478bd9Sstevel@tonic-gate static void
12997c478bd9Sstevel@tonic-gate dtrace_get_SIB(dis86_t *x, uint_t *ss, uint_t *index, uint_t *base)
13007c478bd9Sstevel@tonic-gate {
13017c478bd9Sstevel@tonic-gate 	int byte;
13027c478bd9Sstevel@tonic-gate 
13037c478bd9Sstevel@tonic-gate 	if (x->d86_error)
13047c478bd9Sstevel@tonic-gate 		return;
13057c478bd9Sstevel@tonic-gate 
13067c478bd9Sstevel@tonic-gate 	byte = x->d86_get_byte(x->d86_data);
13077c478bd9Sstevel@tonic-gate 	if (byte < 0) {
13087c478bd9Sstevel@tonic-gate 		x->d86_error = 1;
13097c478bd9Sstevel@tonic-gate 		return;
13107c478bd9Sstevel@tonic-gate 	}
13117c478bd9Sstevel@tonic-gate 	x->d86_bytes[x->d86_len++] = byte;
13127c478bd9Sstevel@tonic-gate 
13137c478bd9Sstevel@tonic-gate 	*base = byte & 0x7;
13147c478bd9Sstevel@tonic-gate 	*index = (byte >> 3) & 0x7;
13157c478bd9Sstevel@tonic-gate 	*ss = (byte >> 6) & 0x3;
13167c478bd9Sstevel@tonic-gate }
13177c478bd9Sstevel@tonic-gate 
13187c478bd9Sstevel@tonic-gate /*
13197c478bd9Sstevel@tonic-gate  * Get the byte following the op code and separate it into the
13207c478bd9Sstevel@tonic-gate  * mode, register, and r/m fields.
13217c478bd9Sstevel@tonic-gate  */
13227c478bd9Sstevel@tonic-gate static void
13237c478bd9Sstevel@tonic-gate dtrace_get_modrm(dis86_t *x, uint_t *mode, uint_t *reg, uint_t *r_m)
13247c478bd9Sstevel@tonic-gate {
13257c478bd9Sstevel@tonic-gate 	if (x->d86_got_modrm == 0) {
13267c478bd9Sstevel@tonic-gate 		if (x->d86_rmindex == -1)
13277c478bd9Sstevel@tonic-gate 			x->d86_rmindex = x->d86_len;
13287c478bd9Sstevel@tonic-gate 		dtrace_get_SIB(x, mode, reg, r_m);
13297c478bd9Sstevel@tonic-gate 		x->d86_got_modrm = 1;
13307c478bd9Sstevel@tonic-gate 	}
13317c478bd9Sstevel@tonic-gate }
13327c478bd9Sstevel@tonic-gate 
13337c478bd9Sstevel@tonic-gate /*
13347c478bd9Sstevel@tonic-gate  * Adjust register selection based on any REX prefix bits present.
13357c478bd9Sstevel@tonic-gate  */
13367c478bd9Sstevel@tonic-gate /*ARGSUSED*/
13377c478bd9Sstevel@tonic-gate static void
13387c478bd9Sstevel@tonic-gate dtrace_rex_adjust(uint_t rex_prefix, uint_t mode, uint_t *reg, uint_t *r_m)
13397c478bd9Sstevel@tonic-gate {
13407c478bd9Sstevel@tonic-gate 	if (reg != NULL && r_m == NULL) {
13417c478bd9Sstevel@tonic-gate 		if (rex_prefix & REX_B)
13427c478bd9Sstevel@tonic-gate 			*reg += 8;
13437c478bd9Sstevel@tonic-gate 	} else {
13447c478bd9Sstevel@tonic-gate 		if (reg != NULL && (REX_R & rex_prefix) != 0)
13457c478bd9Sstevel@tonic-gate 			*reg += 8;
13467c478bd9Sstevel@tonic-gate 		if (r_m != NULL && (REX_B & rex_prefix) != 0)
13477c478bd9Sstevel@tonic-gate 			*r_m += 8;
13487c478bd9Sstevel@tonic-gate 	}
13497c478bd9Sstevel@tonic-gate }
13507c478bd9Sstevel@tonic-gate 
13517c478bd9Sstevel@tonic-gate /*
13527c478bd9Sstevel@tonic-gate  * Get an immediate operand of the given size, with sign extension.
13537c478bd9Sstevel@tonic-gate  */
13547c478bd9Sstevel@tonic-gate static void
13557c478bd9Sstevel@tonic-gate dtrace_imm_opnd(dis86_t *x, int wbit, int size, int opindex)
13567c478bd9Sstevel@tonic-gate {
13577c478bd9Sstevel@tonic-gate 	int i;
13587c478bd9Sstevel@tonic-gate 	int byte;
13597c478bd9Sstevel@tonic-gate 	int valsize;
13607c478bd9Sstevel@tonic-gate 
13617c478bd9Sstevel@tonic-gate 	if (x->d86_numopnds < opindex + 1)
13627c478bd9Sstevel@tonic-gate 		x->d86_numopnds = opindex + 1;
13637c478bd9Sstevel@tonic-gate 
13647c478bd9Sstevel@tonic-gate 	switch (wbit) {
13657c478bd9Sstevel@tonic-gate 	case BYTE_OPND:
13667c478bd9Sstevel@tonic-gate 		valsize = 1;
13677c478bd9Sstevel@tonic-gate 		break;
13687c478bd9Sstevel@tonic-gate 	case LONG_OPND:
13697c478bd9Sstevel@tonic-gate 		if (x->d86_opnd_size == SIZE16)
13707c478bd9Sstevel@tonic-gate 			valsize = 2;
13717c478bd9Sstevel@tonic-gate 		else if (x->d86_opnd_size == SIZE32)
13727c478bd9Sstevel@tonic-gate 			valsize = 4;
13737c478bd9Sstevel@tonic-gate 		else
13747c478bd9Sstevel@tonic-gate 			valsize = 8;
13757c478bd9Sstevel@tonic-gate 		break;
13767c478bd9Sstevel@tonic-gate 	case MM_OPND:
13777c478bd9Sstevel@tonic-gate 	case XMM_OPND:
13787c478bd9Sstevel@tonic-gate 	case SEG_OPND:
13797c478bd9Sstevel@tonic-gate 	case CONTROL_OPND:
13807c478bd9Sstevel@tonic-gate 	case DEBUG_OPND:
13817c478bd9Sstevel@tonic-gate 	case TEST_OPND:
13827c478bd9Sstevel@tonic-gate 		valsize = size;
13837c478bd9Sstevel@tonic-gate 		break;
13847c478bd9Sstevel@tonic-gate 	case WORD_OPND:
13857c478bd9Sstevel@tonic-gate 		valsize = 2;
13867c478bd9Sstevel@tonic-gate 		break;
13877c478bd9Sstevel@tonic-gate 	}
13887c478bd9Sstevel@tonic-gate 	if (valsize < size)
13897c478bd9Sstevel@tonic-gate 		valsize = size;
13907c478bd9Sstevel@tonic-gate 
13917c478bd9Sstevel@tonic-gate 	if (x->d86_error)
13927c478bd9Sstevel@tonic-gate 		return;
13937c478bd9Sstevel@tonic-gate 	x->d86_opnd[opindex].d86_value = 0;
13947c478bd9Sstevel@tonic-gate 	for (i = 0; i < size; ++i) {
13957c478bd9Sstevel@tonic-gate 		byte = x->d86_get_byte(x->d86_data);
13967c478bd9Sstevel@tonic-gate 		if (byte < 0) {
13977c478bd9Sstevel@tonic-gate 			x->d86_error = 1;
13987c478bd9Sstevel@tonic-gate 			return;
13997c478bd9Sstevel@tonic-gate 		}
14007c478bd9Sstevel@tonic-gate 		x->d86_bytes[x->d86_len++] = byte;
14017c478bd9Sstevel@tonic-gate 		x->d86_opnd[opindex].d86_value |= (uint64_t)byte << (i * 8);
14027c478bd9Sstevel@tonic-gate 	}
14037c478bd9Sstevel@tonic-gate 	/* Do sign extension */
14047c478bd9Sstevel@tonic-gate 	if (x->d86_bytes[x->d86_len - 1] & 0x80) {
1405*d267098bSdmick 		for (; i < sizeof (uint64_t); i++)
14067c478bd9Sstevel@tonic-gate 			x->d86_opnd[opindex].d86_value |=
1407*d267098bSdmick 			    (uint64_t)0xff << (i * 8);
14087c478bd9Sstevel@tonic-gate 	}
14097c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
14107c478bd9Sstevel@tonic-gate 	x->d86_opnd[opindex].d86_mode = MODE_SIGNED;
14117c478bd9Sstevel@tonic-gate 	x->d86_opnd[opindex].d86_value_size = valsize;
14127c478bd9Sstevel@tonic-gate 	x->d86_imm_bytes += size;
14137c478bd9Sstevel@tonic-gate #endif
14147c478bd9Sstevel@tonic-gate }
14157c478bd9Sstevel@tonic-gate 
14167c478bd9Sstevel@tonic-gate /*
14177c478bd9Sstevel@tonic-gate  * Get an ip relative operand of the given size, with sign extension.
14187c478bd9Sstevel@tonic-gate  */
14197c478bd9Sstevel@tonic-gate static void
14207c478bd9Sstevel@tonic-gate dtrace_disp_opnd(dis86_t *x, int wbit, int size, int opindex)
14217c478bd9Sstevel@tonic-gate {
14227c478bd9Sstevel@tonic-gate 	dtrace_imm_opnd(x, wbit, size, opindex);
14237c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
14247c478bd9Sstevel@tonic-gate 	x->d86_opnd[opindex].d86_mode = MODE_IPREL;
14257c478bd9Sstevel@tonic-gate #endif
14267c478bd9Sstevel@tonic-gate }
14277c478bd9Sstevel@tonic-gate 
14287c478bd9Sstevel@tonic-gate /*
14297c478bd9Sstevel@tonic-gate  * Check to see if there is a segment override prefix pending.
14307c478bd9Sstevel@tonic-gate  * If so, print it in the current 'operand' location and set
14317c478bd9Sstevel@tonic-gate  * the override flag back to false.
14327c478bd9Sstevel@tonic-gate  */
14337c478bd9Sstevel@tonic-gate /*ARGSUSED*/
14347c478bd9Sstevel@tonic-gate static void
14357c478bd9Sstevel@tonic-gate dtrace_check_override(dis86_t *x, int opindex)
14367c478bd9Sstevel@tonic-gate {
14377c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
14387c478bd9Sstevel@tonic-gate 	if (x->d86_seg_prefix) {
1439dc0093f4Seschrock 		(void) strlcat(x->d86_opnd[opindex].d86_prefix,
14407c478bd9Sstevel@tonic-gate 		    x->d86_seg_prefix, PFIXLEN);
14417c478bd9Sstevel@tonic-gate 	}
14427c478bd9Sstevel@tonic-gate #endif
14437c478bd9Sstevel@tonic-gate 	x->d86_seg_prefix = NULL;
14447c478bd9Sstevel@tonic-gate }
14457c478bd9Sstevel@tonic-gate 
14467c478bd9Sstevel@tonic-gate 
14477c478bd9Sstevel@tonic-gate /*
14487c478bd9Sstevel@tonic-gate  * Process a single instruction Register or Memory operand.
14497c478bd9Sstevel@tonic-gate  *
14507c478bd9Sstevel@tonic-gate  * mode = addressing mode from ModRM byte
14517c478bd9Sstevel@tonic-gate  * r_m = r_m (or reg if mode == 3) field from ModRM byte
14527c478bd9Sstevel@tonic-gate  * wbit = indicates which register (8bit, 16bit, ... MMX, etc.) set to use.
14537c478bd9Sstevel@tonic-gate  * o = index of operand that we are processing (0, 1 or 2)
14547c478bd9Sstevel@tonic-gate  *
14557c478bd9Sstevel@tonic-gate  * the value of reg or r_m must have already been adjusted for any REX prefix.
14567c478bd9Sstevel@tonic-gate  */
14577c478bd9Sstevel@tonic-gate /*ARGSUSED*/
14587c478bd9Sstevel@tonic-gate static void
14597c478bd9Sstevel@tonic-gate dtrace_get_operand(dis86_t *x, uint_t mode, uint_t r_m, int wbit, int opindex)
14607c478bd9Sstevel@tonic-gate {
14617c478bd9Sstevel@tonic-gate 	int have_SIB = 0;	/* flag presence of scale-index-byte */
14627c478bd9Sstevel@tonic-gate 	uint_t ss;		/* scale-factor from opcode */
14637c478bd9Sstevel@tonic-gate 	uint_t index;		/* index register number */
14647c478bd9Sstevel@tonic-gate 	uint_t base;		/* base register number */
14657c478bd9Sstevel@tonic-gate 	int dispsize;   	/* size of displacement in bytes */
14667c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
14677c478bd9Sstevel@tonic-gate 	char *opnd = x->d86_opnd[opindex].d86_opnd;
14687c478bd9Sstevel@tonic-gate #endif
14697c478bd9Sstevel@tonic-gate 
14707c478bd9Sstevel@tonic-gate 	if (x->d86_numopnds < opindex + 1)
14717c478bd9Sstevel@tonic-gate 		x->d86_numopnds = opindex + 1;
14727c478bd9Sstevel@tonic-gate 
14737c478bd9Sstevel@tonic-gate 	if (x->d86_error)
14747c478bd9Sstevel@tonic-gate 		return;
14757c478bd9Sstevel@tonic-gate 
14767c478bd9Sstevel@tonic-gate 	/*
14777c478bd9Sstevel@tonic-gate 	 * first handle a simple register
14787c478bd9Sstevel@tonic-gate 	 */
14797c478bd9Sstevel@tonic-gate 	if (mode == REG_ONLY) {
14807c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
14817c478bd9Sstevel@tonic-gate 		switch (wbit) {
14827c478bd9Sstevel@tonic-gate 		case MM_OPND:
1483dc0093f4Seschrock 			(void) strlcat(opnd, dis_MMREG[r_m], OPLEN);
14847c478bd9Sstevel@tonic-gate 			break;
14857c478bd9Sstevel@tonic-gate 		case XMM_OPND:
1486dc0093f4Seschrock 			(void) strlcat(opnd, dis_XMMREG[r_m], OPLEN);
14877c478bd9Sstevel@tonic-gate 			break;
14887c478bd9Sstevel@tonic-gate 		case SEG_OPND:
1489dc0093f4Seschrock 			(void) strlcat(opnd, dis_SEGREG[r_m], OPLEN);
14907c478bd9Sstevel@tonic-gate 			break;
14917c478bd9Sstevel@tonic-gate 		case CONTROL_OPND:
1492dc0093f4Seschrock 			(void) strlcat(opnd, dis_CONTROLREG[r_m], OPLEN);
14937c478bd9Sstevel@tonic-gate 			break;
14947c478bd9Sstevel@tonic-gate 		case DEBUG_OPND:
1495dc0093f4Seschrock 			(void) strlcat(opnd, dis_DEBUGREG[r_m], OPLEN);
14967c478bd9Sstevel@tonic-gate 			break;
14977c478bd9Sstevel@tonic-gate 		case TEST_OPND:
1498dc0093f4Seschrock 			(void) strlcat(opnd, dis_TESTREG[r_m], OPLEN);
14997c478bd9Sstevel@tonic-gate 			break;
15007c478bd9Sstevel@tonic-gate 		case BYTE_OPND:
15017c478bd9Sstevel@tonic-gate 			if (x->d86_rex_prefix == 0)
1502dc0093f4Seschrock 				(void) strlcat(opnd, dis_REG8[r_m], OPLEN);
15037c478bd9Sstevel@tonic-gate 			else
1504dc0093f4Seschrock 				(void) strlcat(opnd, dis_REG8_REX[r_m], OPLEN);
15057c478bd9Sstevel@tonic-gate 			break;
15067c478bd9Sstevel@tonic-gate 		case WORD_OPND:
1507dc0093f4Seschrock 			(void) strlcat(opnd, dis_REG16[r_m], OPLEN);
15087c478bd9Sstevel@tonic-gate 			break;
15097c478bd9Sstevel@tonic-gate 		case LONG_OPND:
15107c478bd9Sstevel@tonic-gate 			if (x->d86_opnd_size == SIZE16)
1511dc0093f4Seschrock 				(void) strlcat(opnd, dis_REG16[r_m], OPLEN);
15127c478bd9Sstevel@tonic-gate 			else if (x->d86_opnd_size == SIZE32)
1513dc0093f4Seschrock 				(void) strlcat(opnd, dis_REG32[r_m], OPLEN);
15147c478bd9Sstevel@tonic-gate 			else
1515dc0093f4Seschrock 				(void) strlcat(opnd, dis_REG64[r_m], OPLEN);
15167c478bd9Sstevel@tonic-gate 			break;
15177c478bd9Sstevel@tonic-gate 		}
15187c478bd9Sstevel@tonic-gate #endif /* DIS_TEXT */
15197c478bd9Sstevel@tonic-gate 		return;
15207c478bd9Sstevel@tonic-gate 	}
15217c478bd9Sstevel@tonic-gate 
15227c478bd9Sstevel@tonic-gate 	/*
15237c478bd9Sstevel@tonic-gate 	 * if symbolic representation, skip override prefix, if any
15247c478bd9Sstevel@tonic-gate 	 */
15257c478bd9Sstevel@tonic-gate 	dtrace_check_override(x, opindex);
15267c478bd9Sstevel@tonic-gate 
15277c478bd9Sstevel@tonic-gate 	/*
15287c478bd9Sstevel@tonic-gate 	 * Handle 16 bit memory references first, since they decode
15297c478bd9Sstevel@tonic-gate 	 * the mode values more simply.
15307c478bd9Sstevel@tonic-gate 	 * mode 1 is r_m + 8 bit displacement
15317c478bd9Sstevel@tonic-gate 	 * mode 2 is r_m + 16 bit displacement
15327c478bd9Sstevel@tonic-gate 	 * mode 0 is just r_m, unless r_m is 6 which is 16 bit disp
15337c478bd9Sstevel@tonic-gate 	 */
15347c478bd9Sstevel@tonic-gate 	if (x->d86_addr_size == SIZE16) {
15357c478bd9Sstevel@tonic-gate 		if ((mode == 0 && r_m == 6) || mode == 2)
15367c478bd9Sstevel@tonic-gate 			dtrace_imm_opnd(x, WORD_OPND, 2, opindex);
15377c478bd9Sstevel@tonic-gate 		else if (mode == 1)
15387c478bd9Sstevel@tonic-gate 			dtrace_imm_opnd(x, BYTE_OPND, 1, opindex);
15397c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
15407c478bd9Sstevel@tonic-gate 		if (mode == 0 && r_m == 6)
15417c478bd9Sstevel@tonic-gate 			x->d86_opnd[opindex].d86_mode = MODE_SIGNED;
15427c478bd9Sstevel@tonic-gate 		else if (mode == 0)
15437c478bd9Sstevel@tonic-gate 			x->d86_opnd[opindex].d86_mode = MODE_NONE;
15447c478bd9Sstevel@tonic-gate 		else
15457c478bd9Sstevel@tonic-gate 			x->d86_opnd[opindex].d86_mode = MODE_OFFSET;
1546dc0093f4Seschrock 		(void) strlcat(opnd, dis_addr16[mode][r_m], OPLEN);
15477c478bd9Sstevel@tonic-gate #endif
15487c478bd9Sstevel@tonic-gate 		return;
15497c478bd9Sstevel@tonic-gate 	}
15507c478bd9Sstevel@tonic-gate 
15517c478bd9Sstevel@tonic-gate 	/*
15527c478bd9Sstevel@tonic-gate 	 * 32 and 64 bit addressing modes are more complex since they
15537c478bd9Sstevel@tonic-gate 	 * can involve an SIB (scaled index and base) byte to decode.
15547c478bd9Sstevel@tonic-gate 	 */
15557c478bd9Sstevel@tonic-gate 	if (r_m == ESP_REGNO || r_m == ESP_REGNO + 8) {
15567c478bd9Sstevel@tonic-gate 		have_SIB = 1;
15577c478bd9Sstevel@tonic-gate 		dtrace_get_SIB(x, &ss, &index, &base);
15587c478bd9Sstevel@tonic-gate 		if (x->d86_error)
15597c478bd9Sstevel@tonic-gate 			return;
15607c478bd9Sstevel@tonic-gate 		if (base != 5 || mode != 0)
15617c478bd9Sstevel@tonic-gate 			if (x->d86_rex_prefix & REX_B)
15627c478bd9Sstevel@tonic-gate 				base += 8;
15637c478bd9Sstevel@tonic-gate 		if (x->d86_rex_prefix & REX_X)
15647c478bd9Sstevel@tonic-gate 			index += 8;
15657c478bd9Sstevel@tonic-gate 	} else {
15667c478bd9Sstevel@tonic-gate 		base = r_m;
15677c478bd9Sstevel@tonic-gate 	}
15687c478bd9Sstevel@tonic-gate 
15697c478bd9Sstevel@tonic-gate 	/*
15707c478bd9Sstevel@tonic-gate 	 * Compute the displacement size and get its bytes
15717c478bd9Sstevel@tonic-gate 	 */
15727c478bd9Sstevel@tonic-gate 	dispsize = 0;
15737c478bd9Sstevel@tonic-gate 
15747c478bd9Sstevel@tonic-gate 	if (mode == 1)
15757c478bd9Sstevel@tonic-gate 		dispsize = 1;
15767c478bd9Sstevel@tonic-gate 	else if (mode == 2)
15777c478bd9Sstevel@tonic-gate 		dispsize = 4;
15787c478bd9Sstevel@tonic-gate 	else if ((r_m & 7) == EBP_REGNO ||
15797c478bd9Sstevel@tonic-gate 	    (have_SIB && (base & 7) == EBP_REGNO))
15807c478bd9Sstevel@tonic-gate 		dispsize = 4;
15817c478bd9Sstevel@tonic-gate 
15827c478bd9Sstevel@tonic-gate 	if (dispsize > 0) {
15837c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, dispsize == 4 ? LONG_OPND : BYTE_OPND,
15847c478bd9Sstevel@tonic-gate 		    dispsize, opindex);
15857c478bd9Sstevel@tonic-gate 		if (x->d86_error)
15867c478bd9Sstevel@tonic-gate 			return;
15877c478bd9Sstevel@tonic-gate 	}
15887c478bd9Sstevel@tonic-gate 
15897c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
15907c478bd9Sstevel@tonic-gate 	if (dispsize > 0)
15917c478bd9Sstevel@tonic-gate 		x->d86_opnd[opindex].d86_mode = MODE_OFFSET;
15927c478bd9Sstevel@tonic-gate 
15937c478bd9Sstevel@tonic-gate 	if (have_SIB == 0) {
15947c478bd9Sstevel@tonic-gate 		if (x->d86_mode == SIZE32) {
15957c478bd9Sstevel@tonic-gate 			if (mode == 0)
1596dc0093f4Seschrock 				(void) strlcat(opnd, dis_addr32_mode0[r_m],
15977c478bd9Sstevel@tonic-gate 				    OPLEN);
15987c478bd9Sstevel@tonic-gate 			else
1599dc0093f4Seschrock 				(void) strlcat(opnd, dis_addr32_mode12[r_m],
16007c478bd9Sstevel@tonic-gate 				    OPLEN);
16017c478bd9Sstevel@tonic-gate 		} else {
1602*d267098bSdmick 			if (mode == 0) {
1603dc0093f4Seschrock 				(void) strlcat(opnd, dis_addr64_mode0[r_m],
16047c478bd9Sstevel@tonic-gate 				    OPLEN);
1605*d267098bSdmick 				if (r_m == 5) {
1606*d267098bSdmick 					x->d86_opnd[opindex].d86_mode =
1607*d267098bSdmick 					    MODE_RIPREL;
1608*d267098bSdmick 				}
1609*d267098bSdmick 			} else {
1610dc0093f4Seschrock 				(void) strlcat(opnd, dis_addr64_mode12[r_m],
16117c478bd9Sstevel@tonic-gate 				    OPLEN);
1612*d267098bSdmick 			}
16137c478bd9Sstevel@tonic-gate 		}
16147c478bd9Sstevel@tonic-gate 	} else {
16157c478bd9Sstevel@tonic-gate 		uint_t need_paren = 0;
16167c478bd9Sstevel@tonic-gate 		char **regs;
16177c478bd9Sstevel@tonic-gate 		if (x->d86_mode == SIZE32) /* NOTE this is not addr_size! */
16187c478bd9Sstevel@tonic-gate 			regs = (char **)dis_REG32;
16197c478bd9Sstevel@tonic-gate 		else
16207c478bd9Sstevel@tonic-gate 			regs = (char **)dis_REG64;
16217c478bd9Sstevel@tonic-gate 
16227c478bd9Sstevel@tonic-gate 		/*
16237c478bd9Sstevel@tonic-gate 		 * print the base (if any)
16247c478bd9Sstevel@tonic-gate 		 */
16257c478bd9Sstevel@tonic-gate 		if (base == EBP_REGNO && mode == 0) {
16267c478bd9Sstevel@tonic-gate 			if (index != ESP_REGNO) {
1627dc0093f4Seschrock 				(void) strlcat(opnd, "(", OPLEN);
16287c478bd9Sstevel@tonic-gate 				need_paren = 1;
16297c478bd9Sstevel@tonic-gate 			}
16307c478bd9Sstevel@tonic-gate 		} else {
1631dc0093f4Seschrock 			(void) strlcat(opnd, "(", OPLEN);
1632dc0093f4Seschrock 			(void) strlcat(opnd, regs[base], OPLEN);
16337c478bd9Sstevel@tonic-gate 			need_paren = 1;
16347c478bd9Sstevel@tonic-gate 		}
16357c478bd9Sstevel@tonic-gate 
16367c478bd9Sstevel@tonic-gate 		/*
16377c478bd9Sstevel@tonic-gate 		 * print the index (if any)
16387c478bd9Sstevel@tonic-gate 		 */
16397c478bd9Sstevel@tonic-gate 		if (index != ESP_REGNO) {
1640dc0093f4Seschrock 			(void) strlcat(opnd, ",", OPLEN);
1641dc0093f4Seschrock 			(void) strlcat(opnd, regs[index], OPLEN);
1642dc0093f4Seschrock 			(void) strlcat(opnd, dis_scale_factor[ss], OPLEN);
16437c478bd9Sstevel@tonic-gate 		} else
16447c478bd9Sstevel@tonic-gate 			if (need_paren)
1645dc0093f4Seschrock 				(void) strlcat(opnd, ")", OPLEN);
16467c478bd9Sstevel@tonic-gate 	}
16477c478bd9Sstevel@tonic-gate #endif
16487c478bd9Sstevel@tonic-gate }
16497c478bd9Sstevel@tonic-gate 
16507c478bd9Sstevel@tonic-gate /*
16517c478bd9Sstevel@tonic-gate  * Operand sequence for standard instruction involving one register
16527c478bd9Sstevel@tonic-gate  * and one register/memory operand.
16537c478bd9Sstevel@tonic-gate  * wbit indicates a byte(0) or opnd_size(1) operation
16547c478bd9Sstevel@tonic-gate  * vbit indicates direction (0 for "opcode r,r_m") or (1 for "opcode r_m, r")
16557c478bd9Sstevel@tonic-gate  */
16567c478bd9Sstevel@tonic-gate #define	STANDARD_MODRM(x, mode, reg, r_m, rex_prefix, wbit, vbit)  {	\
16577c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);			\
16587c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, &r_m);	\
16597c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, vbit);		\
16607c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, wbit, 1 - vbit);	\
16617c478bd9Sstevel@tonic-gate }
16627c478bd9Sstevel@tonic-gate 
16637c478bd9Sstevel@tonic-gate /*
16647c478bd9Sstevel@tonic-gate  * Similar to above, but allows for the two operands to be of different
16657c478bd9Sstevel@tonic-gate  * classes (ie. wbit).
16667c478bd9Sstevel@tonic-gate  *	wbit is for the r_m operand
16677c478bd9Sstevel@tonic-gate  *	w2 is for the reg operand
16687c478bd9Sstevel@tonic-gate  */
16697c478bd9Sstevel@tonic-gate #define	MIXED_MM(x, mode, reg, r_m, rex_prefix, wbit, w2, vbit)	{	\
16707c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);			\
16717c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, &r_m);	\
16727c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, vbit);		\
16737c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, w2, 1 - vbit);	\
16747c478bd9Sstevel@tonic-gate }
16757c478bd9Sstevel@tonic-gate 
16767c478bd9Sstevel@tonic-gate /*
16777c478bd9Sstevel@tonic-gate  * Similar, but for 2 operands plus an immediate.
16787c478bd9Sstevel@tonic-gate  */
16797c478bd9Sstevel@tonic-gate #define	THREEOPERAND(x, mode, reg, r_m, rex_prefix, wbit, w2, immsize) { \
16807c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);			\
16817c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, &r_m);	\
16827c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 1);		\
16837c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, w2, 2);		\
16847c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, immsize, 0);			\
16857c478bd9Sstevel@tonic-gate }
16867c478bd9Sstevel@tonic-gate 
16877c478bd9Sstevel@tonic-gate /*
16887c478bd9Sstevel@tonic-gate  * Dissassemble a single x86 or amd64 instruction.
16897c478bd9Sstevel@tonic-gate  *
16907c478bd9Sstevel@tonic-gate  * Mode determines the default operating mode (SIZE16, SIZE32 or SIZE64)
16917c478bd9Sstevel@tonic-gate  * for interpreting instructions.
16927c478bd9Sstevel@tonic-gate  *
16937c478bd9Sstevel@tonic-gate  * returns non-zero for bad opcode
16947c478bd9Sstevel@tonic-gate  */
16957c478bd9Sstevel@tonic-gate int
16967c478bd9Sstevel@tonic-gate dtrace_disx86(dis86_t *x, uint_t cpu_mode)
16977c478bd9Sstevel@tonic-gate {
16987c478bd9Sstevel@tonic-gate 	instable_t *dp;		/* decode table being used */
16997c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
17007c478bd9Sstevel@tonic-gate 	uint_t i;
17017c478bd9Sstevel@tonic-gate #endif
17027c478bd9Sstevel@tonic-gate #ifdef DIS_MEM
17037c478bd9Sstevel@tonic-gate 	uint_t nomem = 0;
17047c478bd9Sstevel@tonic-gate #define	NOMEM	(nomem = 1)
17057c478bd9Sstevel@tonic-gate #else
17067c478bd9Sstevel@tonic-gate #define	NOMEM	/* nothing */
17077c478bd9Sstevel@tonic-gate #endif
17087c478bd9Sstevel@tonic-gate 	uint_t wbit;		/* opcode wbit, 0 is 8 bit, !0 for opnd_size */
17097c478bd9Sstevel@tonic-gate 	uint_t w2;		/* wbit value for second operand */
17107c478bd9Sstevel@tonic-gate 	uint_t vbit;
17117c478bd9Sstevel@tonic-gate 	uint_t mode = 0;	/* mode value from ModRM byte */
17127c478bd9Sstevel@tonic-gate 	uint_t reg;		/* reg value from ModRM byte */
17137c478bd9Sstevel@tonic-gate 	uint_t r_m;		/* r_m value from ModRM byte */
17147c478bd9Sstevel@tonic-gate 
17157c478bd9Sstevel@tonic-gate 	uint_t opcode1;		/* high nibble of 1st byte */
17167c478bd9Sstevel@tonic-gate 	uint_t opcode2;		/* low nibble of 1st byte */
17177c478bd9Sstevel@tonic-gate 	uint_t opcode3;		/* extra opcode bits usually from ModRM byte */
17187c478bd9Sstevel@tonic-gate 	uint_t opcode4;		/* high nibble of 2nd byte */
1719*d267098bSdmick 	uint_t opcode5;		/* low nibble of 2nd byte */
17207c478bd9Sstevel@tonic-gate 	uint_t opcode6;		/* high nibble of 3rd byte */
17217c478bd9Sstevel@tonic-gate 	uint_t opcode7;		/* low nibble of 3rd byte */
17227c478bd9Sstevel@tonic-gate 	uint_t opcode_bytes = 1;
17237c478bd9Sstevel@tonic-gate 
17247c478bd9Sstevel@tonic-gate 	/*
17257c478bd9Sstevel@tonic-gate 	 * legacy prefixes come in 5 flavors, you should have only one of each
17267c478bd9Sstevel@tonic-gate 	 */
17277c478bd9Sstevel@tonic-gate 	uint_t	opnd_size_prefix = 0;
17287c478bd9Sstevel@tonic-gate 	uint_t	addr_size_prefix = 0;
17297c478bd9Sstevel@tonic-gate 	uint_t	segment_prefix = 0;
17307c478bd9Sstevel@tonic-gate 	uint_t	lock_prefix = 0;
17317c478bd9Sstevel@tonic-gate 	uint_t	rep_prefix = 0;
17327c478bd9Sstevel@tonic-gate 	uint_t	rex_prefix = 0;	/* amd64 register extension prefix */
17337c478bd9Sstevel@tonic-gate 	size_t	off;
17347c478bd9Sstevel@tonic-gate 
17357c478bd9Sstevel@tonic-gate 	x->d86_len = 0;
17367c478bd9Sstevel@tonic-gate 	x->d86_rmindex = -1;
17377c478bd9Sstevel@tonic-gate 	x->d86_error = 0;
17387c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
17397c478bd9Sstevel@tonic-gate 	x->d86_numopnds = 0;
17407c478bd9Sstevel@tonic-gate 	x->d86_seg_prefix = NULL;
1741*d267098bSdmick 	x->d86_mnem[0] = 0;
17427c478bd9Sstevel@tonic-gate 	for (i = 0; i < 3; ++i) {
17437c478bd9Sstevel@tonic-gate 		x->d86_opnd[i].d86_opnd[0] = 0;
17447c478bd9Sstevel@tonic-gate 		x->d86_opnd[i].d86_prefix[0] = 0;
17457c478bd9Sstevel@tonic-gate 		x->d86_opnd[i].d86_value_size = 0;
17467c478bd9Sstevel@tonic-gate 		x->d86_opnd[i].d86_value = 0;
17477c478bd9Sstevel@tonic-gate 		x->d86_opnd[i].d86_mode = MODE_NONE;
17487c478bd9Sstevel@tonic-gate 	}
17497c478bd9Sstevel@tonic-gate #endif
17507c478bd9Sstevel@tonic-gate 	x->d86_error = 0;
17517c478bd9Sstevel@tonic-gate 	x->d86_memsize = 0;
17527c478bd9Sstevel@tonic-gate 
17537c478bd9Sstevel@tonic-gate 	if (cpu_mode == SIZE16) {
17547c478bd9Sstevel@tonic-gate 		opnd_size = SIZE16;
17557c478bd9Sstevel@tonic-gate 		addr_size = SIZE16;
17567c478bd9Sstevel@tonic-gate 	} else if (cpu_mode == SIZE32) {
17577c478bd9Sstevel@tonic-gate 		opnd_size = SIZE32;
17587c478bd9Sstevel@tonic-gate 		addr_size = SIZE32;
17597c478bd9Sstevel@tonic-gate 	} else {
17607c478bd9Sstevel@tonic-gate 		opnd_size = SIZE32;
17617c478bd9Sstevel@tonic-gate 		addr_size = SIZE64;
17627c478bd9Sstevel@tonic-gate 	}
17637c478bd9Sstevel@tonic-gate 
17647c478bd9Sstevel@tonic-gate 	/*
17657c478bd9Sstevel@tonic-gate 	 * Get one opcode byte and check for zero padding that follows
17667c478bd9Sstevel@tonic-gate 	 * jump tables.
17677c478bd9Sstevel@tonic-gate 	 */
17687c478bd9Sstevel@tonic-gate 	if (dtrace_get_opcode(x, &opcode1, &opcode2) != 0)
17697c478bd9Sstevel@tonic-gate 		goto error;
17707c478bd9Sstevel@tonic-gate 
17717c478bd9Sstevel@tonic-gate 	if (opcode1 == 0 && opcode2 == 0 &&
1772dc0093f4Seschrock 	    x->d86_check_func != NULL && x->d86_check_func(x->d86_data)) {
17737c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
1774*d267098bSdmick 		(void) strncpy(x->d86_mnem, ".byte\t0", OPLEN);
17757c478bd9Sstevel@tonic-gate #endif
17767c478bd9Sstevel@tonic-gate 		goto done;
17777c478bd9Sstevel@tonic-gate 	}
17787c478bd9Sstevel@tonic-gate 
17797c478bd9Sstevel@tonic-gate 	/*
17807c478bd9Sstevel@tonic-gate 	 * Gather up legacy x86 prefix bytes.
17817c478bd9Sstevel@tonic-gate 	 */
17827c478bd9Sstevel@tonic-gate 	for (;;) {
17837c478bd9Sstevel@tonic-gate 		uint_t *which_prefix = NULL;
17847c478bd9Sstevel@tonic-gate 
17857c478bd9Sstevel@tonic-gate 		dp = (instable_t *)&dis_distable[opcode1][opcode2];
17867c478bd9Sstevel@tonic-gate 
17877c478bd9Sstevel@tonic-gate 		switch (dp->it_adrmode) {
17887c478bd9Sstevel@tonic-gate 		case PREFIX:
17897c478bd9Sstevel@tonic-gate 			which_prefix = &rep_prefix;
17907c478bd9Sstevel@tonic-gate 			break;
17917c478bd9Sstevel@tonic-gate 		case LOCK:
17927c478bd9Sstevel@tonic-gate 			which_prefix = &lock_prefix;
17937c478bd9Sstevel@tonic-gate 			break;
17947c478bd9Sstevel@tonic-gate 		case OVERRIDE:
17957c478bd9Sstevel@tonic-gate 			which_prefix = &segment_prefix;
17967c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
17977c478bd9Sstevel@tonic-gate 			x->d86_seg_prefix = (char *)dp->it_name;
17987c478bd9Sstevel@tonic-gate #endif
17997c478bd9Sstevel@tonic-gate 			if (dp->it_invalid64 && cpu_mode == SIZE64)
18007c478bd9Sstevel@tonic-gate 				goto error;
18017c478bd9Sstevel@tonic-gate 			break;
18027c478bd9Sstevel@tonic-gate 		case AM:
18037c478bd9Sstevel@tonic-gate 			which_prefix = &addr_size_prefix;
18047c478bd9Sstevel@tonic-gate 			break;
18057c478bd9Sstevel@tonic-gate 		case DM:
18067c478bd9Sstevel@tonic-gate 			which_prefix = &opnd_size_prefix;
18077c478bd9Sstevel@tonic-gate 			break;
18087c478bd9Sstevel@tonic-gate 		}
18097c478bd9Sstevel@tonic-gate 		if (which_prefix == NULL)
18107c478bd9Sstevel@tonic-gate 			break;
18117c478bd9Sstevel@tonic-gate 		*which_prefix = (opcode1 << 4) | opcode2;
18127c478bd9Sstevel@tonic-gate 		if (dtrace_get_opcode(x, &opcode1, &opcode2) != 0)
18137c478bd9Sstevel@tonic-gate 			goto error;
18147c478bd9Sstevel@tonic-gate 	}
18157c478bd9Sstevel@tonic-gate 
18167c478bd9Sstevel@tonic-gate 	/*
18177c478bd9Sstevel@tonic-gate 	 * Handle amd64 mode PREFIX values.
18187c478bd9Sstevel@tonic-gate 	 * Some of the segment prefixes are no-ops. (only FS/GS actually work)
18197c478bd9Sstevel@tonic-gate 	 * We might have a REX prefix (opcodes 0x40-0x4f)
18207c478bd9Sstevel@tonic-gate 	 */
18217c478bd9Sstevel@tonic-gate 	if (cpu_mode == SIZE64) {
18227c478bd9Sstevel@tonic-gate 		if (segment_prefix != 0x64 && segment_prefix != 0x65)
18237c478bd9Sstevel@tonic-gate 			segment_prefix = 0;
18247c478bd9Sstevel@tonic-gate 
18257c478bd9Sstevel@tonic-gate 		if (opcode1 == 0x4) {
18267c478bd9Sstevel@tonic-gate 			rex_prefix = (opcode1 << 4) | opcode2;
18277c478bd9Sstevel@tonic-gate 			if (dtrace_get_opcode(x, &opcode1, &opcode2) != 0)
18287c478bd9Sstevel@tonic-gate 				goto error;
18297c478bd9Sstevel@tonic-gate 			dp = (instable_t *)&dis_distable[opcode1][opcode2];
18307c478bd9Sstevel@tonic-gate 		}
18317c478bd9Sstevel@tonic-gate 	}
18327c478bd9Sstevel@tonic-gate 
18337c478bd9Sstevel@tonic-gate 	/*
18347c478bd9Sstevel@tonic-gate 	 * Deal with selection of operand and address size now.
18357c478bd9Sstevel@tonic-gate 	 * Note that the REX.W bit being set causes opnd_size_prefix to be
18367c478bd9Sstevel@tonic-gate 	 * ignored.
18377c478bd9Sstevel@tonic-gate 	 */
18387c478bd9Sstevel@tonic-gate 	if (cpu_mode == SIZE64) {
1839*d267098bSdmick 		if (rex_prefix & REX_W)
18407c478bd9Sstevel@tonic-gate 			opnd_size = SIZE64;
18417c478bd9Sstevel@tonic-gate 		else if (opnd_size_prefix)
18427c478bd9Sstevel@tonic-gate 			opnd_size = SIZE16;
18437c478bd9Sstevel@tonic-gate 
18447c478bd9Sstevel@tonic-gate 		if (addr_size_prefix)
18457c478bd9Sstevel@tonic-gate 			addr_size = SIZE32;
18467c478bd9Sstevel@tonic-gate 	} else if (cpu_mode == SIZE32) {
18477c478bd9Sstevel@tonic-gate 		if (opnd_size_prefix)
18487c478bd9Sstevel@tonic-gate 			opnd_size = SIZE16;
18497c478bd9Sstevel@tonic-gate 		if (addr_size_prefix)
18507c478bd9Sstevel@tonic-gate 			addr_size = SIZE16;
18517c478bd9Sstevel@tonic-gate 	} else {
18527c478bd9Sstevel@tonic-gate 		if (opnd_size_prefix)
18537c478bd9Sstevel@tonic-gate 			opnd_size = SIZE32;
18547c478bd9Sstevel@tonic-gate 		if (addr_size_prefix)
18557c478bd9Sstevel@tonic-gate 			addr_size = SIZE32;
18567c478bd9Sstevel@tonic-gate 	}
18577c478bd9Sstevel@tonic-gate 
18587c478bd9Sstevel@tonic-gate 	/*
18597c478bd9Sstevel@tonic-gate 	 * The pause instruction - a repz'd nop.  This doesn't fit
18607c478bd9Sstevel@tonic-gate 	 * with any of the other prefix goop added for SSE, so we'll
18617c478bd9Sstevel@tonic-gate 	 * special-case it here.
18627c478bd9Sstevel@tonic-gate 	 */
18637c478bd9Sstevel@tonic-gate 	if (rep_prefix == 0xf3 && opcode1 == 0x9 && opcode2 == 0x0) {
18647c478bd9Sstevel@tonic-gate 		rep_prefix = 0;
18657c478bd9Sstevel@tonic-gate 		dp = (instable_t *)&dis_opPause;
18667c478bd9Sstevel@tonic-gate 	}
18677c478bd9Sstevel@tonic-gate 
18687c478bd9Sstevel@tonic-gate 	/*
18697c478bd9Sstevel@tonic-gate 	 * Some 386 instructions have 2 bytes of opcode before the mod_r/m
18707c478bd9Sstevel@tonic-gate 	 * byte so we may need to perform a table indirection.
18717c478bd9Sstevel@tonic-gate 	 */
18727c478bd9Sstevel@tonic-gate 	if (dp->it_indirect == (instable_t *)dis_op0F) {
18737c478bd9Sstevel@tonic-gate 		if (dtrace_get_opcode(x, &opcode4, &opcode5) != 0)
18747c478bd9Sstevel@tonic-gate 			goto error;
18757c478bd9Sstevel@tonic-gate 		opcode_bytes = 2;
18767c478bd9Sstevel@tonic-gate 		if (opcode4 == 0x7 && opcode5 >= 0x1 && opcode5 <= 0x3) {
18777c478bd9Sstevel@tonic-gate 			uint_t	subcode;
18787c478bd9Sstevel@tonic-gate 
18797c478bd9Sstevel@tonic-gate 			if (dtrace_get_opcode(x, &opcode6, &opcode7) != 0)
18807c478bd9Sstevel@tonic-gate 				goto error;
18817c478bd9Sstevel@tonic-gate 			opcode_bytes = 3;
18827c478bd9Sstevel@tonic-gate 			subcode = ((opcode6 & 0x3) << 1) |
18837c478bd9Sstevel@tonic-gate 			    ((opcode7 & 0x8) >> 3);
18847c478bd9Sstevel@tonic-gate 			dp = (instable_t *)&dis_op0F7123[opcode5][subcode];
18857c478bd9Sstevel@tonic-gate 		} else if ((opcode4 == 0xc) && (opcode5 >= 0x8)) {
18867c478bd9Sstevel@tonic-gate 			dp = (instable_t *)&dis_op0FC8[0];
18877c478bd9Sstevel@tonic-gate 		} else {
18887c478bd9Sstevel@tonic-gate 			dp = (instable_t *)&dis_op0F[opcode4][opcode5];
18897c478bd9Sstevel@tonic-gate 		}
18907c478bd9Sstevel@tonic-gate 	}
18917c478bd9Sstevel@tonic-gate 
18927c478bd9Sstevel@tonic-gate 	/*
18937c478bd9Sstevel@tonic-gate 	 * If still not at a TERM decode entry, then a ModRM byte
18947c478bd9Sstevel@tonic-gate 	 * exists and its fields further decode the instruction.
18957c478bd9Sstevel@tonic-gate 	 */
18967c478bd9Sstevel@tonic-gate 	x->d86_got_modrm = 0;
18977c478bd9Sstevel@tonic-gate 	if (dp->it_indirect != TERM) {
18987c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &opcode3, &r_m);
18997c478bd9Sstevel@tonic-gate 		if (x->d86_error)
19007c478bd9Sstevel@tonic-gate 			goto error;
19017c478bd9Sstevel@tonic-gate 		reg = opcode3;
19027c478bd9Sstevel@tonic-gate 
19037c478bd9Sstevel@tonic-gate 		/*
19047c478bd9Sstevel@tonic-gate 		 * decode 287 instructions (D8-DF) from opcodeN
19057c478bd9Sstevel@tonic-gate 		 */
19067c478bd9Sstevel@tonic-gate 		if (opcode1 == 0xD && opcode2 >= 0x8) {
19077c478bd9Sstevel@tonic-gate 			if (opcode2 == 0xB && mode == 0x3 && opcode3 == 4)
19087c478bd9Sstevel@tonic-gate 				dp = (instable_t *)&dis_opFP5[r_m];
19097c478bd9Sstevel@tonic-gate 			else if (opcode2 == 0xA && mode == 0x3 && opcode3 < 4)
19107c478bd9Sstevel@tonic-gate 				dp = (instable_t *)&dis_opFP7[opcode3];
19117c478bd9Sstevel@tonic-gate 			else if (opcode2 == 0xB && mode == 0x3)
19127c478bd9Sstevel@tonic-gate 				dp = (instable_t *)&dis_opFP6[opcode3];
19137c478bd9Sstevel@tonic-gate 			else if (opcode2 == 0x9 && mode == 0x3 && opcode3 >= 4)
19147c478bd9Sstevel@tonic-gate 				dp = (instable_t *)&dis_opFP4[opcode3 - 4][r_m];
19157c478bd9Sstevel@tonic-gate 			else if (mode == 0x3)
19167c478bd9Sstevel@tonic-gate 				dp = (instable_t *)
19177c478bd9Sstevel@tonic-gate 				    &dis_opFP3[opcode2 - 8][opcode3];
19187c478bd9Sstevel@tonic-gate 			else
19197c478bd9Sstevel@tonic-gate 				dp = (instable_t *)
19207c478bd9Sstevel@tonic-gate 				    &dis_opFP1n2[opcode2 - 8][opcode3];
19217c478bd9Sstevel@tonic-gate 		} else {
19227c478bd9Sstevel@tonic-gate 			dp = (instable_t *)dp->it_indirect + opcode3;
19237c478bd9Sstevel@tonic-gate 		}
19247c478bd9Sstevel@tonic-gate 	}
19257c478bd9Sstevel@tonic-gate 
19267c478bd9Sstevel@tonic-gate 	/*
19277c478bd9Sstevel@tonic-gate 	 * In amd64 bit mode, ARPL opcode is changed to MOVSXD
19287c478bd9Sstevel@tonic-gate 	 * (sign extend 32bit to 64 bit)
19297c478bd9Sstevel@tonic-gate 	 */
19307c478bd9Sstevel@tonic-gate 	if (cpu_mode == SIZE64 && opcode1 == 0x6 && opcode2 == 0x3)
19317c478bd9Sstevel@tonic-gate 		dp = (instable_t *)&dis_opMOVSLD;
19327c478bd9Sstevel@tonic-gate 
19337c478bd9Sstevel@tonic-gate 	/*
19347c478bd9Sstevel@tonic-gate 	 * at this point we should have a correct (or invalid) opcode
19357c478bd9Sstevel@tonic-gate 	 */
19367c478bd9Sstevel@tonic-gate 	if (cpu_mode == SIZE64 && dp->it_invalid64 ||
19377c478bd9Sstevel@tonic-gate 	    cpu_mode != SIZE64 && dp->it_invalid32)
19387c478bd9Sstevel@tonic-gate 		goto error;
19397c478bd9Sstevel@tonic-gate 	if (dp->it_indirect != TERM)
19407c478bd9Sstevel@tonic-gate 		goto error;
19417c478bd9Sstevel@tonic-gate 
19427c478bd9Sstevel@tonic-gate 	/*
19437c478bd9Sstevel@tonic-gate 	 * deal with MMX/SSE opcodes which are changed by prefixes
19447c478bd9Sstevel@tonic-gate 	 */
19457c478bd9Sstevel@tonic-gate 	switch (dp->it_adrmode) {
19467c478bd9Sstevel@tonic-gate 	case MMO:
19477c478bd9Sstevel@tonic-gate 	case MMOIMPL:
19487c478bd9Sstevel@tonic-gate 	case MMO3P:
19497c478bd9Sstevel@tonic-gate 	case MMOM3:
19507c478bd9Sstevel@tonic-gate 	case MMOMS:
19517c478bd9Sstevel@tonic-gate 	case MMOPM:
19527c478bd9Sstevel@tonic-gate 	case MMOPRM:
19537c478bd9Sstevel@tonic-gate 	case MMOS:
19547c478bd9Sstevel@tonic-gate 	case XMMO:
19557c478bd9Sstevel@tonic-gate 	case XMMOM:
19567c478bd9Sstevel@tonic-gate 	case XMMOMS:
19577c478bd9Sstevel@tonic-gate 	case XMMOPM:
19587c478bd9Sstevel@tonic-gate 	case XMMOS:
19597c478bd9Sstevel@tonic-gate 	case XMMOMX:
19607c478bd9Sstevel@tonic-gate 	case XMMOX3:
19617c478bd9Sstevel@tonic-gate 	case XMMOXMM:
19627c478bd9Sstevel@tonic-gate 		/*
19637c478bd9Sstevel@tonic-gate 		 * This is horrible.  Some SIMD instructions take the
19647c478bd9Sstevel@tonic-gate 		 * form 0x0F 0x?? ..., which is easily decoded using the
19657c478bd9Sstevel@tonic-gate 		 * existing tables.  Other SIMD instructions use various
19667c478bd9Sstevel@tonic-gate 		 * prefix bytes to overload existing instructions.  For
19677c478bd9Sstevel@tonic-gate 		 * Example, addps is F0, 58, whereas addss is F3 (repz),
19687c478bd9Sstevel@tonic-gate 		 * F0, 58.  Presumably someone got a raise for this.
19697c478bd9Sstevel@tonic-gate 		 *
19707c478bd9Sstevel@tonic-gate 		 * If we see one of the instructions which can be
19717c478bd9Sstevel@tonic-gate 		 * modified in this way (if we've got one of the SIMDO*
19727c478bd9Sstevel@tonic-gate 		 * address modes), we'll check to see if the last prefix
19737c478bd9Sstevel@tonic-gate 		 * was a repz.  If it was, we strip the prefix from the
19747c478bd9Sstevel@tonic-gate 		 * mnemonic, and we indirect using the dis_opSIMDrepz
19757c478bd9Sstevel@tonic-gate 		 * table.
19767c478bd9Sstevel@tonic-gate 		 */
19777c478bd9Sstevel@tonic-gate 
19787c478bd9Sstevel@tonic-gate 		/*
19797c478bd9Sstevel@tonic-gate 		 * Calculate our offset in dis_op0F
19807c478bd9Sstevel@tonic-gate 		 */
19817c478bd9Sstevel@tonic-gate 		if ((uintptr_t)dp - (uintptr_t)dis_op0F > sizeof (dis_op0F))
19827c478bd9Sstevel@tonic-gate 			goto error;
19837c478bd9Sstevel@tonic-gate 
19847c478bd9Sstevel@tonic-gate 		off = ((uintptr_t)dp - (uintptr_t)dis_op0F) /
19857c478bd9Sstevel@tonic-gate 		    sizeof (instable_t);
19867c478bd9Sstevel@tonic-gate 
19877c478bd9Sstevel@tonic-gate 		/*
19887c478bd9Sstevel@tonic-gate 		 * Rewrite if this instruction used one of the magic prefixes.
19897c478bd9Sstevel@tonic-gate 		 */
19907c478bd9Sstevel@tonic-gate 		if (rep_prefix) {
19917c478bd9Sstevel@tonic-gate 			if (rep_prefix == 0xf2)
19927c478bd9Sstevel@tonic-gate 				dp = (instable_t *)&dis_opSIMDrepnz[off];
19937c478bd9Sstevel@tonic-gate 			else
19947c478bd9Sstevel@tonic-gate 				dp = (instable_t *)&dis_opSIMDrepz[off];
19957c478bd9Sstevel@tonic-gate 			rep_prefix = 0;
19967c478bd9Sstevel@tonic-gate 		} else if (opnd_size_prefix) {
19977c478bd9Sstevel@tonic-gate 			dp = (instable_t *)&dis_opSIMDdata16[off];
19987c478bd9Sstevel@tonic-gate 			opnd_size_prefix = 0;
19997c478bd9Sstevel@tonic-gate 			if (opnd_size == SIZE16)
20007c478bd9Sstevel@tonic-gate 				opnd_size = SIZE32;
20017c478bd9Sstevel@tonic-gate 		}
20027c478bd9Sstevel@tonic-gate 		break;
20037c478bd9Sstevel@tonic-gate 
20047c478bd9Sstevel@tonic-gate 	case MMOSH:
20057c478bd9Sstevel@tonic-gate 		/*
20067c478bd9Sstevel@tonic-gate 		 * As with the "normal" SIMD instructions, the MMX
20077c478bd9Sstevel@tonic-gate 		 * shuffle instructions are overloaded.  These
20087c478bd9Sstevel@tonic-gate 		 * instructions, however, are special in that they use
20097c478bd9Sstevel@tonic-gate 		 * an extra byte, and thus an extra table.  As of this
20107c478bd9Sstevel@tonic-gate 		 * writing, they only use the opnd_size prefix.
20117c478bd9Sstevel@tonic-gate 		 */
20127c478bd9Sstevel@tonic-gate 
20137c478bd9Sstevel@tonic-gate 		/*
20147c478bd9Sstevel@tonic-gate 		 * Calculate our offset in dis_op0F7123
20157c478bd9Sstevel@tonic-gate 		 */
20167c478bd9Sstevel@tonic-gate 		if ((uintptr_t)dp - (uintptr_t)dis_op0F7123 >
20177c478bd9Sstevel@tonic-gate 		    sizeof (dis_op0F7123))
20187c478bd9Sstevel@tonic-gate 			goto error;
20197c478bd9Sstevel@tonic-gate 
20207c478bd9Sstevel@tonic-gate 		if (opnd_size_prefix) {
20217c478bd9Sstevel@tonic-gate 			off = ((uintptr_t)dp - (uintptr_t)dis_op0F7123) /
20227c478bd9Sstevel@tonic-gate 			    sizeof (instable_t);
20237c478bd9Sstevel@tonic-gate 			dp = (instable_t *)&dis_opSIMD7123[off];
20247c478bd9Sstevel@tonic-gate 			opnd_size_prefix = 0;
20257c478bd9Sstevel@tonic-gate 			if (opnd_size == SIZE16)
20267c478bd9Sstevel@tonic-gate 				opnd_size = SIZE32;
20277c478bd9Sstevel@tonic-gate 		}
20287c478bd9Sstevel@tonic-gate 		break;
20297c478bd9Sstevel@tonic-gate 	}
20307c478bd9Sstevel@tonic-gate 
20317c478bd9Sstevel@tonic-gate 	/*
20327c478bd9Sstevel@tonic-gate 	 * In 64 bit mode, some opcodes automatically use opnd_size == SIZE64.
20337c478bd9Sstevel@tonic-gate 	 */
20347c478bd9Sstevel@tonic-gate 	if (cpu_mode == SIZE64)
20357c478bd9Sstevel@tonic-gate 		if (dp->it_always64 || (opnd_size == SIZE32 && dp->it_stackop))
20367c478bd9Sstevel@tonic-gate 			opnd_size = SIZE64;
20377c478bd9Sstevel@tonic-gate 
20387c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
20397c478bd9Sstevel@tonic-gate 	/*
20407c478bd9Sstevel@tonic-gate 	 * At this point most instructions can format the opcode mnemonic
20417c478bd9Sstevel@tonic-gate 	 * including the prefixes.
20427c478bd9Sstevel@tonic-gate 	 */
20437c478bd9Sstevel@tonic-gate 	if (lock_prefix)
2044*d267098bSdmick 		(void) strlcat(x->d86_mnem, "lock ", OPLEN);
20457c478bd9Sstevel@tonic-gate 
20467c478bd9Sstevel@tonic-gate 	if (rep_prefix == 0xf2)
2047*d267098bSdmick 		(void) strlcat(x->d86_mnem, "repnz ", OPLEN);
20487c478bd9Sstevel@tonic-gate 	else if (rep_prefix == 0xf3)
2049*d267098bSdmick 		(void) strlcat(x->d86_mnem, "repz ", OPLEN);
20507c478bd9Sstevel@tonic-gate 
20517c478bd9Sstevel@tonic-gate 	if (cpu_mode == SIZE64 && addr_size_prefix)
2052*d267098bSdmick 		(void) strlcat(x->d86_mnem, "addr32 ", OPLEN);
20537c478bd9Sstevel@tonic-gate 
20547c478bd9Sstevel@tonic-gate 	if (dp->it_adrmode != CBW &&
20557c478bd9Sstevel@tonic-gate 	    dp->it_adrmode != CWD &&
20567c478bd9Sstevel@tonic-gate 	    dp->it_adrmode != XMMSFNC) {
20577c478bd9Sstevel@tonic-gate 		if (strcmp(dp->it_name, "INVALID") == 0)
20587c478bd9Sstevel@tonic-gate 			goto error;
2059*d267098bSdmick 		(void) strlcat(x->d86_mnem, dp->it_name, OPLEN);
20607c478bd9Sstevel@tonic-gate 		if (dp->it_suffix) {
20617c478bd9Sstevel@tonic-gate 			char *types[] = {"", "w", "l", "q"};
20627c478bd9Sstevel@tonic-gate 			if (opcode_bytes == 2 && opcode4 == 4) {
20637c478bd9Sstevel@tonic-gate 				/* It's a cmovx.yy. Replace the suffix x */
20647c478bd9Sstevel@tonic-gate 				for (i = 5; i < OPLEN; i++) {
2065*d267098bSdmick 					if (x->d86_mnem[i] == '.')
20667c478bd9Sstevel@tonic-gate 						break;
20677c478bd9Sstevel@tonic-gate 				}
2068*d267098bSdmick 				x->d86_mnem[i - 1] = *types[opnd_size];
2069dc0093f4Seschrock 			} else {
2070*d267098bSdmick 				(void) strlcat(x->d86_mnem, types[opnd_size],
2071dc0093f4Seschrock 				    OPLEN);
2072dc0093f4Seschrock 			}
20737c478bd9Sstevel@tonic-gate 		}
20747c478bd9Sstevel@tonic-gate 	}
20757c478bd9Sstevel@tonic-gate #endif
20767c478bd9Sstevel@tonic-gate 
20777c478bd9Sstevel@tonic-gate 	/*
20787c478bd9Sstevel@tonic-gate 	 * Process operands based on the addressing modes.
20797c478bd9Sstevel@tonic-gate 	 */
20807c478bd9Sstevel@tonic-gate 	x->d86_mode = cpu_mode;
20817c478bd9Sstevel@tonic-gate 	x->d86_rex_prefix = rex_prefix;
20827c478bd9Sstevel@tonic-gate 	x->d86_opnd_size = opnd_size;
20837c478bd9Sstevel@tonic-gate 	x->d86_addr_size = addr_size;
20847c478bd9Sstevel@tonic-gate 	vbit = 0;		/* initialize for mem/reg -> reg */
20857c478bd9Sstevel@tonic-gate 	switch (dp->it_adrmode) {
20867c478bd9Sstevel@tonic-gate 		/*
20877c478bd9Sstevel@tonic-gate 		 * amd64 instruction to sign extend 32 bit reg/mem operands
20887c478bd9Sstevel@tonic-gate 		 * into 64 bit register values
20897c478bd9Sstevel@tonic-gate 		 */
20907c478bd9Sstevel@tonic-gate 	case MOVSXZ:
20917c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
20927c478bd9Sstevel@tonic-gate 		if (rex_prefix == 0)
2093*d267098bSdmick 			(void) strncpy(x->d86_mnem, "movzld", OPLEN);
20947c478bd9Sstevel@tonic-gate #endif
20957c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
20967c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, &r_m);
20977c478bd9Sstevel@tonic-gate 		x->d86_opnd_size = SIZE64;
20987c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, LONG_OPND, 1);
20997c478bd9Sstevel@tonic-gate 		x->d86_opnd_size = opnd_size = SIZE32;
21007c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
21017c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 0);
21027c478bd9Sstevel@tonic-gate 		break;
21037c478bd9Sstevel@tonic-gate 
21047c478bd9Sstevel@tonic-gate 		/*
21057c478bd9Sstevel@tonic-gate 		 * movsbl movsbw movsbq (0x0FBE) or movswl movswq (0x0FBF)
2106*d267098bSdmick 		 * movzbl movzbw movzbq (0x0FB6) or movzwl movzwq (0x0FB7)
21077c478bd9Sstevel@tonic-gate 		 * wbit lives in 2nd byte, note that operands
21087c478bd9Sstevel@tonic-gate 		 * are different sized
21097c478bd9Sstevel@tonic-gate 		 */
21107c478bd9Sstevel@tonic-gate 	case MOVZ:
21117c478bd9Sstevel@tonic-gate 		if (rex_prefix & REX_W) {
21127c478bd9Sstevel@tonic-gate 			/* target register size = 64 bit */
2113*d267098bSdmick 			x->d86_mnem[5] = 'q';
21147c478bd9Sstevel@tonic-gate 		}
21157c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
21167c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, &r_m);
21177c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, LONG_OPND, 1);
21187c478bd9Sstevel@tonic-gate 		x->d86_opnd_size = opnd_size = SIZE16;
21197c478bd9Sstevel@tonic-gate 		wbit = WBIT(opcode5);
21207c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 0);
21217c478bd9Sstevel@tonic-gate 		break;
21227c478bd9Sstevel@tonic-gate 
21237c478bd9Sstevel@tonic-gate 	/*
21247c478bd9Sstevel@tonic-gate 	 * imul instruction, with either 8-bit or longer immediate
21257c478bd9Sstevel@tonic-gate 	 * opcode 0x6B for byte, sign-extended displacement, 0x69 for word(s)
21267c478bd9Sstevel@tonic-gate 	 */
21277c478bd9Sstevel@tonic-gate 	case IMUL:
21287c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
21297c478bd9Sstevel@tonic-gate 		THREEOPERAND(x, mode, reg, r_m, rex_prefix, wbit, LONG_OPND,
21307c478bd9Sstevel@tonic-gate 		    OPSIZE(opnd_size, opcode2 == 0x9));
21317c478bd9Sstevel@tonic-gate 		break;
21327c478bd9Sstevel@tonic-gate 
21337c478bd9Sstevel@tonic-gate 	/* memory or register operand to register, with 'w' bit	*/
21347c478bd9Sstevel@tonic-gate 	case MRw:
21357c478bd9Sstevel@tonic-gate 		wbit = WBIT(opcode2);
21367c478bd9Sstevel@tonic-gate 		STANDARD_MODRM(x, mode, reg, r_m, rex_prefix, wbit, 0);
21377c478bd9Sstevel@tonic-gate 		break;
21387c478bd9Sstevel@tonic-gate 
21397c478bd9Sstevel@tonic-gate 	/* register to memory or register operand, with 'w' bit	*/
21407c478bd9Sstevel@tonic-gate 	/* arpl happens to fit here also because it is odd */
21417c478bd9Sstevel@tonic-gate 	case RMw:
21427c478bd9Sstevel@tonic-gate 		if (opcode_bytes == 2)
21437c478bd9Sstevel@tonic-gate 			wbit = WBIT(opcode5);
21447c478bd9Sstevel@tonic-gate 		else
21457c478bd9Sstevel@tonic-gate 			wbit = WBIT(opcode2);
21467c478bd9Sstevel@tonic-gate 		STANDARD_MODRM(x, mode, reg, r_m, rex_prefix, wbit, 1);
21477c478bd9Sstevel@tonic-gate 		break;
21487c478bd9Sstevel@tonic-gate 
21497c478bd9Sstevel@tonic-gate 	/* xaddb instruction */
21507c478bd9Sstevel@tonic-gate 	case XADDB:
21517c478bd9Sstevel@tonic-gate 		wbit = 0;
21527c478bd9Sstevel@tonic-gate 		STANDARD_MODRM(x, mode, reg, r_m, rex_prefix, wbit, 1);
21537c478bd9Sstevel@tonic-gate 		break;
21547c478bd9Sstevel@tonic-gate 
21557c478bd9Sstevel@tonic-gate 	/* MMX register to memory or register operand		*/
21567c478bd9Sstevel@tonic-gate 	case MMS:
21577c478bd9Sstevel@tonic-gate 	case MMOS:
21587c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
21597c478bd9Sstevel@tonic-gate 		wbit = strcmp(dp->it_name, "movd") ? MM_OPND : LONG_OPND;
21607c478bd9Sstevel@tonic-gate #else
21617c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
21627c478bd9Sstevel@tonic-gate #endif
21637c478bd9Sstevel@tonic-gate 		MIXED_MM(x, mode, reg, r_m, rex_prefix, wbit, MM_OPND, 1);
21647c478bd9Sstevel@tonic-gate 		break;
21657c478bd9Sstevel@tonic-gate 
21667c478bd9Sstevel@tonic-gate 	/* MMX register to memory */
21677c478bd9Sstevel@tonic-gate 	case MMOMS:
21687c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
21697c478bd9Sstevel@tonic-gate 		if (mode == REG_ONLY)
21707c478bd9Sstevel@tonic-gate 			goto error;
21717c478bd9Sstevel@tonic-gate 		wbit = MM_OPND;
21727c478bd9Sstevel@tonic-gate 		MIXED_MM(x, mode, reg, r_m, rex_prefix, wbit, MM_OPND, 1);
21737c478bd9Sstevel@tonic-gate 		break;
21747c478bd9Sstevel@tonic-gate 
21757c478bd9Sstevel@tonic-gate 	/* Double shift. Has immediate operand specifying the shift. */
21767c478bd9Sstevel@tonic-gate 	case DSHIFT:
21777c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
21787c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
21797c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, &r_m);
21807c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 2);
21817c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, LONG_OPND, 1);
21827c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, 1, 0);
21837c478bd9Sstevel@tonic-gate 		break;
21847c478bd9Sstevel@tonic-gate 
21857c478bd9Sstevel@tonic-gate 	/*
21867c478bd9Sstevel@tonic-gate 	 * Double shift. With no immediate operand, specifies using %cl.
21877c478bd9Sstevel@tonic-gate 	 */
21887c478bd9Sstevel@tonic-gate 	case DSHIFTcl:
21897c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
21907c478bd9Sstevel@tonic-gate 		STANDARD_MODRM(x, mode, reg, r_m, rex_prefix, wbit, 1);
21917c478bd9Sstevel@tonic-gate 		break;
21927c478bd9Sstevel@tonic-gate 
21937c478bd9Sstevel@tonic-gate 	/* immediate to memory or register operand */
21947c478bd9Sstevel@tonic-gate 	case IMlw:
21957c478bd9Sstevel@tonic-gate 		wbit = WBIT(opcode2);
21967c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, NULL, &r_m);
21977c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 1);
21987c478bd9Sstevel@tonic-gate 		/*
21997c478bd9Sstevel@tonic-gate 		 * Have long immediate for opcode 0x81, but not 0x80 nor 0x83
22007c478bd9Sstevel@tonic-gate 		 */
22017c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, OPSIZE(opnd_size, opcode2 == 1), 0);
22027c478bd9Sstevel@tonic-gate 		break;
22037c478bd9Sstevel@tonic-gate 
22047c478bd9Sstevel@tonic-gate 	/* immediate to memory or register operand with the	*/
22057c478bd9Sstevel@tonic-gate 	/* 'w' bit present					*/
22067c478bd9Sstevel@tonic-gate 	case IMw:
22077c478bd9Sstevel@tonic-gate 		wbit = WBIT(opcode2);
22087c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
22097c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, NULL, &r_m);
22107c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 1);
22117c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, OPSIZE(opnd_size, wbit), 0);
22127c478bd9Sstevel@tonic-gate 		break;
22137c478bd9Sstevel@tonic-gate 
22147c478bd9Sstevel@tonic-gate 	/* immediate to register with register in low 3 bits	*/
22157c478bd9Sstevel@tonic-gate 	/* of op code						*/
22167c478bd9Sstevel@tonic-gate 	case IR:
22177c478bd9Sstevel@tonic-gate 		/* w-bit here (with regs) is bit 3 */
22187c478bd9Sstevel@tonic-gate 		wbit = opcode2 >>3 & 0x1;
22197c478bd9Sstevel@tonic-gate 		reg = REGNO(opcode2);
22207c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, NULL);
22217c478bd9Sstevel@tonic-gate 		mode = REG_ONLY;
22227c478bd9Sstevel@tonic-gate 		r_m = reg;
22237c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 1);
22247c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, OPSIZE64(opnd_size, wbit), 0);
22257c478bd9Sstevel@tonic-gate 		break;
22267c478bd9Sstevel@tonic-gate 
22277c478bd9Sstevel@tonic-gate 	/* MMX immediate shift of register */
22287c478bd9Sstevel@tonic-gate 	case MMSH:
22297c478bd9Sstevel@tonic-gate 	case MMOSH:
22307c478bd9Sstevel@tonic-gate 		wbit = MM_OPND;
22317c478bd9Sstevel@tonic-gate 		goto mm_shift;	/* in next case */
22327c478bd9Sstevel@tonic-gate 
22337c478bd9Sstevel@tonic-gate 	/* SIMD immediate shift of register */
22347c478bd9Sstevel@tonic-gate 	case XMMSH:
22357c478bd9Sstevel@tonic-gate 		wbit = XMM_OPND;
22367c478bd9Sstevel@tonic-gate mm_shift:
22377c478bd9Sstevel@tonic-gate 		reg = REGNO(opcode7);
22387c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, NULL);
22397c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, wbit, 1);
22407c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, 1, 0);
22417c478bd9Sstevel@tonic-gate 		NOMEM;
22427c478bd9Sstevel@tonic-gate 		break;
22437c478bd9Sstevel@tonic-gate 
22447c478bd9Sstevel@tonic-gate 	/* accumulator to memory operand */
22457c478bd9Sstevel@tonic-gate 	case AO:
22467c478bd9Sstevel@tonic-gate 		vbit = 1;
22477c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
22487c478bd9Sstevel@tonic-gate 
22497c478bd9Sstevel@tonic-gate 	/* memory operand to accumulator */
22507c478bd9Sstevel@tonic-gate 	case OA:
22517c478bd9Sstevel@tonic-gate 		wbit = WBIT(opcode2);
22527c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, EAX_REGNO, wbit, 1 - vbit);
22537c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, OPSIZE64(addr_size, LONG_OPND), vbit);
22547c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
22557c478bd9Sstevel@tonic-gate 		x->d86_opnd[vbit].d86_mode = MODE_OFFSET;
22567c478bd9Sstevel@tonic-gate #endif
22577c478bd9Sstevel@tonic-gate 		break;
22587c478bd9Sstevel@tonic-gate 
22597c478bd9Sstevel@tonic-gate 
22607c478bd9Sstevel@tonic-gate 	/* segment register to memory or register operand */
22617c478bd9Sstevel@tonic-gate 	case SM:
22627c478bd9Sstevel@tonic-gate 		vbit = 1;
22637c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
22647c478bd9Sstevel@tonic-gate 
22657c478bd9Sstevel@tonic-gate 	/* memory or register operand to segment register */
22667c478bd9Sstevel@tonic-gate 	case MS:
22677c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
22687c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, NULL, &r_m);
22697c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, LONG_OPND, vbit);
22707c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, SEG_OPND, 1 - vbit);
22717c478bd9Sstevel@tonic-gate 		break;
22727c478bd9Sstevel@tonic-gate 
22737c478bd9Sstevel@tonic-gate 	/*
22747c478bd9Sstevel@tonic-gate 	 * rotate or shift instructions, which may shift by 1 or
22757c478bd9Sstevel@tonic-gate 	 * consult the cl register, depending on the 'v' bit
22767c478bd9Sstevel@tonic-gate 	 */
22777c478bd9Sstevel@tonic-gate 	case Mv:
22787c478bd9Sstevel@tonic-gate 		vbit = VBIT(opcode2);
22797c478bd9Sstevel@tonic-gate 		wbit = WBIT(opcode2);
22807c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, NULL, &r_m);
22817c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 1);
22827c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
22837c478bd9Sstevel@tonic-gate 		if (vbit) {
2284dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[0].d86_opnd, "%cl", OPLEN);
22857c478bd9Sstevel@tonic-gate 		} else {
22867c478bd9Sstevel@tonic-gate 			x->d86_opnd[0].d86_mode = MODE_SIGNED;
22877c478bd9Sstevel@tonic-gate 			x->d86_opnd[0].d86_value_size = 1;
22887c478bd9Sstevel@tonic-gate 			x->d86_opnd[0].d86_value = 1;
22897c478bd9Sstevel@tonic-gate 		}
22907c478bd9Sstevel@tonic-gate #endif
22917c478bd9Sstevel@tonic-gate 		break;
22927c478bd9Sstevel@tonic-gate 	/*
22937c478bd9Sstevel@tonic-gate 	 * immediate rotate or shift instructions
22947c478bd9Sstevel@tonic-gate 	 */
22957c478bd9Sstevel@tonic-gate 	case MvI:
22967c478bd9Sstevel@tonic-gate 		wbit = WBIT(opcode2);
22977c478bd9Sstevel@tonic-gate normal_imm_mem:
22987c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, NULL, &r_m);
22997c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 1);
23007c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, 1, 0);
23017c478bd9Sstevel@tonic-gate 		break;
23027c478bd9Sstevel@tonic-gate 
23037c478bd9Sstevel@tonic-gate 	/* bit test instructions */
23047c478bd9Sstevel@tonic-gate 	case MIb:
23057c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
23067c478bd9Sstevel@tonic-gate 		goto normal_imm_mem;
23077c478bd9Sstevel@tonic-gate 
23087c478bd9Sstevel@tonic-gate 	/* single memory or register operand with 'w' bit present */
23097c478bd9Sstevel@tonic-gate 	case Mw:
23107c478bd9Sstevel@tonic-gate 		wbit = WBIT(opcode2);
23117c478bd9Sstevel@tonic-gate just_mem:
23127c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
23137c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, NULL, &r_m);
23147c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 0);
23157c478bd9Sstevel@tonic-gate 		break;
23167c478bd9Sstevel@tonic-gate 
23177c478bd9Sstevel@tonic-gate 	case SWAPGS:
23187c478bd9Sstevel@tonic-gate 		if (cpu_mode == SIZE64 && mode == 3 && r_m == 0) {
23197c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
2320*d267098bSdmick 			(void) strncpy(x->d86_mnem, "swapgs", OPLEN);
23217c478bd9Sstevel@tonic-gate #endif
23227c478bd9Sstevel@tonic-gate 			NOMEM;
23237c478bd9Sstevel@tonic-gate 			break;
23247c478bd9Sstevel@tonic-gate 		}
23257c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
23267c478bd9Sstevel@tonic-gate 
23277c478bd9Sstevel@tonic-gate 	/* prefetch instruction - memory operand, but no memory acess */
23287c478bd9Sstevel@tonic-gate 	case PREF:
23297c478bd9Sstevel@tonic-gate 		NOMEM;
23307c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
23317c478bd9Sstevel@tonic-gate 
23327c478bd9Sstevel@tonic-gate 	/* single memory or register operand */
23337c478bd9Sstevel@tonic-gate 	case M:
23347c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
23357c478bd9Sstevel@tonic-gate 		goto just_mem;
23367c478bd9Sstevel@tonic-gate 
23377c478bd9Sstevel@tonic-gate 	/* single memory or register byte operand */
23387c478bd9Sstevel@tonic-gate 	case Mb:
23397c478bd9Sstevel@tonic-gate 		wbit = BYTE_OPND;
23407c478bd9Sstevel@tonic-gate 		goto just_mem;
23417c478bd9Sstevel@tonic-gate 
23427c478bd9Sstevel@tonic-gate 	case MO:
23437c478bd9Sstevel@tonic-gate 		/* Similar to M, but only memory (no direct registers) */
23447c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
23457c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
23467c478bd9Sstevel@tonic-gate 		if (mode == 3)
23477c478bd9Sstevel@tonic-gate 			goto error;
23487c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, NULL, &r_m);
23497c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 0);
23507c478bd9Sstevel@tonic-gate 		break;
23517c478bd9Sstevel@tonic-gate 
23527c478bd9Sstevel@tonic-gate 	/* move special register to register or reverse if vbit */
23537c478bd9Sstevel@tonic-gate 	case SREG:
23547c478bd9Sstevel@tonic-gate 		switch (opcode5) {
23557c478bd9Sstevel@tonic-gate 
23567c478bd9Sstevel@tonic-gate 		case 2:
23577c478bd9Sstevel@tonic-gate 			vbit = 1;
23587c478bd9Sstevel@tonic-gate 			/*FALLTHROUGH*/
23597c478bd9Sstevel@tonic-gate 		case 0:
23607c478bd9Sstevel@tonic-gate 			wbit = CONTROL_OPND;
23617c478bd9Sstevel@tonic-gate 			break;
23627c478bd9Sstevel@tonic-gate 
23637c478bd9Sstevel@tonic-gate 		case 3:
23647c478bd9Sstevel@tonic-gate 			vbit = 1;
23657c478bd9Sstevel@tonic-gate 			/*FALLTHROUGH*/
23667c478bd9Sstevel@tonic-gate 		case 1:
23677c478bd9Sstevel@tonic-gate 			wbit = DEBUG_OPND;
23687c478bd9Sstevel@tonic-gate 			break;
23697c478bd9Sstevel@tonic-gate 
23707c478bd9Sstevel@tonic-gate 		case 6:
23717c478bd9Sstevel@tonic-gate 			vbit = 1;
23727c478bd9Sstevel@tonic-gate 			/*FALLTHROUGH*/
23737c478bd9Sstevel@tonic-gate 		case 4:
23747c478bd9Sstevel@tonic-gate 			wbit = TEST_OPND;
23757c478bd9Sstevel@tonic-gate 			break;
23767c478bd9Sstevel@tonic-gate 
23777c478bd9Sstevel@tonic-gate 		}
23787c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
23797c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, &r_m);
23807c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, wbit, vbit);
23817c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, r_m, LONG_OPND, 1 - vbit);
23827c478bd9Sstevel@tonic-gate 		NOMEM;
23837c478bd9Sstevel@tonic-gate 		break;
23847c478bd9Sstevel@tonic-gate 
23857c478bd9Sstevel@tonic-gate 	/*
23867c478bd9Sstevel@tonic-gate 	 * single register operand with register in the low 3
23877c478bd9Sstevel@tonic-gate 	 * bits of op code
23887c478bd9Sstevel@tonic-gate 	 */
23897c478bd9Sstevel@tonic-gate 	case R:
23907c478bd9Sstevel@tonic-gate 		if (opcode_bytes == 2)
23917c478bd9Sstevel@tonic-gate 			reg = REGNO(opcode5);
23927c478bd9Sstevel@tonic-gate 		else
23937c478bd9Sstevel@tonic-gate 			reg = REGNO(opcode2);
23947c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, NULL);
23957c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, LONG_OPND, 0);
23967c478bd9Sstevel@tonic-gate 		NOMEM;
23977c478bd9Sstevel@tonic-gate 		break;
23987c478bd9Sstevel@tonic-gate 
23997c478bd9Sstevel@tonic-gate 	/*
24007c478bd9Sstevel@tonic-gate 	 * register to accumulator with register in the low 3
24017c478bd9Sstevel@tonic-gate 	 * bits of op code, xchg instructions
24027c478bd9Sstevel@tonic-gate 	 */
24037c478bd9Sstevel@tonic-gate 	case RA:
24047c478bd9Sstevel@tonic-gate 		NOMEM;
24057c478bd9Sstevel@tonic-gate 		reg = REGNO(opcode2);
24067c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, NULL);
24077c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, LONG_OPND, 0);
24087c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, EAX_REGNO, LONG_OPND, 1);
24097c478bd9Sstevel@tonic-gate 		break;
24107c478bd9Sstevel@tonic-gate 
24117c478bd9Sstevel@tonic-gate 	/*
24127c478bd9Sstevel@tonic-gate 	 * single segment register operand, with register in
24137c478bd9Sstevel@tonic-gate 	 * bits 3-4 of op code byte
24147c478bd9Sstevel@tonic-gate 	 */
24157c478bd9Sstevel@tonic-gate 	case SEG:
24167c478bd9Sstevel@tonic-gate 		NOMEM;
24177c478bd9Sstevel@tonic-gate 		reg = (x->d86_bytes[x->d86_len - 1] >> 3) & 0x3;
24187c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, SEG_OPND, 0);
24197c478bd9Sstevel@tonic-gate 		break;
24207c478bd9Sstevel@tonic-gate 
24217c478bd9Sstevel@tonic-gate 	/*
24227c478bd9Sstevel@tonic-gate 	 * single segment register operand, with register in
24237c478bd9Sstevel@tonic-gate 	 * bits 3-5 of op code
24247c478bd9Sstevel@tonic-gate 	 */
24257c478bd9Sstevel@tonic-gate 	case LSEG:
24267c478bd9Sstevel@tonic-gate 		NOMEM;
24277c478bd9Sstevel@tonic-gate 		/* long seg reg from opcode */
24287c478bd9Sstevel@tonic-gate 		reg = (x->d86_bytes[x->d86_len - 1] >> 3) & 0x7;
24297c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, SEG_OPND, 0);
24307c478bd9Sstevel@tonic-gate 		break;
24317c478bd9Sstevel@tonic-gate 
24327c478bd9Sstevel@tonic-gate 	/* memory or register operand to register */
24337c478bd9Sstevel@tonic-gate 	case MR:
24347c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
24357c478bd9Sstevel@tonic-gate 		STANDARD_MODRM(x, mode, reg, r_m, rex_prefix, wbit, 0);
24367c478bd9Sstevel@tonic-gate 		break;
24377c478bd9Sstevel@tonic-gate 
24387c478bd9Sstevel@tonic-gate 	case RM:
24397c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
24407c478bd9Sstevel@tonic-gate 		STANDARD_MODRM(x, mode, reg, r_m, rex_prefix, wbit, 1);
24417c478bd9Sstevel@tonic-gate 		break;
24427c478bd9Sstevel@tonic-gate 
24437c478bd9Sstevel@tonic-gate 	/* MMX/SIMD-Int memory or mm reg to mm reg		*/
24447c478bd9Sstevel@tonic-gate 	case MM:
24457c478bd9Sstevel@tonic-gate 	case MMO:
24467c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
24477c478bd9Sstevel@tonic-gate 		wbit = strcmp(dp->it_name, "movd") ? MM_OPND : LONG_OPND;
24487c478bd9Sstevel@tonic-gate #else
24497c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
24507c478bd9Sstevel@tonic-gate #endif
24517c478bd9Sstevel@tonic-gate 		MIXED_MM(x, mode, reg, r_m, rex_prefix, wbit, MM_OPND, 0);
24527c478bd9Sstevel@tonic-gate 		break;
24537c478bd9Sstevel@tonic-gate 
24547c478bd9Sstevel@tonic-gate 	case MMOIMPL:
24557c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
24567c478bd9Sstevel@tonic-gate 		wbit = strcmp(dp->it_name, "movd") ? MM_OPND : LONG_OPND;
24577c478bd9Sstevel@tonic-gate #else
24587c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
24597c478bd9Sstevel@tonic-gate #endif
24607c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
24617c478bd9Sstevel@tonic-gate 		if (mode != REG_ONLY)
24627c478bd9Sstevel@tonic-gate 			goto error;
24637c478bd9Sstevel@tonic-gate 
24647c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, &r_m);
24657c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 0);
24667c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, MM_OPND, 1);
24677c478bd9Sstevel@tonic-gate 		mode = 0;	/* change for memory access size... */
24687c478bd9Sstevel@tonic-gate 		break;
24697c478bd9Sstevel@tonic-gate 
24707c478bd9Sstevel@tonic-gate 	/* MMX/SIMD-Int and SIMD-FP predicated mm reg to r32 */
24717c478bd9Sstevel@tonic-gate 	case MMO3P:
24727c478bd9Sstevel@tonic-gate 		wbit = MM_OPND;
24737c478bd9Sstevel@tonic-gate 		goto xmm3p;
24747c478bd9Sstevel@tonic-gate 	case XMM3P:
24757c478bd9Sstevel@tonic-gate 		wbit = XMM_OPND;
24767c478bd9Sstevel@tonic-gate xmm3p:
24777c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
24787c478bd9Sstevel@tonic-gate 		if (mode != REG_ONLY)
24797c478bd9Sstevel@tonic-gate 			goto error;
24807c478bd9Sstevel@tonic-gate 
24817c478bd9Sstevel@tonic-gate 		THREEOPERAND(x, mode, reg, r_m, rex_prefix, wbit, LONG_OPND, 1);
24827c478bd9Sstevel@tonic-gate 		NOMEM;
24837c478bd9Sstevel@tonic-gate 		break;
24847c478bd9Sstevel@tonic-gate 
24857c478bd9Sstevel@tonic-gate 	/* MMX/SIMD-Int predicated r32/mem to mm reg */
24867c478bd9Sstevel@tonic-gate 	case MMOPRM:
24877c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
24887c478bd9Sstevel@tonic-gate 		w2 = MM_OPND;
24897c478bd9Sstevel@tonic-gate 		goto xmmprm;
24907c478bd9Sstevel@tonic-gate 	case XMMPRM:
24917c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
24927c478bd9Sstevel@tonic-gate 		w2 = XMM_OPND;
24937c478bd9Sstevel@tonic-gate xmmprm:
24947c478bd9Sstevel@tonic-gate 		THREEOPERAND(x, mode, reg, r_m, rex_prefix, wbit, w2, 1);
24957c478bd9Sstevel@tonic-gate 		break;
24967c478bd9Sstevel@tonic-gate 
24977c478bd9Sstevel@tonic-gate 	/* MMX/SIMD-Int predicated mm/mem to mm reg */
24987c478bd9Sstevel@tonic-gate 	case MMOPM:
24997c478bd9Sstevel@tonic-gate 		wbit = w2 = MM_OPND;
25007c478bd9Sstevel@tonic-gate 		goto xmmprm;
25017c478bd9Sstevel@tonic-gate 
25027c478bd9Sstevel@tonic-gate 	/* MMX/SIMD-Int mm reg to r32 */
25037c478bd9Sstevel@tonic-gate 	case MMOM3:
25047c478bd9Sstevel@tonic-gate 		NOMEM;
25057c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
25067c478bd9Sstevel@tonic-gate 		if (mode != REG_ONLY)
25077c478bd9Sstevel@tonic-gate 			goto error;
25087c478bd9Sstevel@tonic-gate 		wbit = MM_OPND;
25097c478bd9Sstevel@tonic-gate 		MIXED_MM(x, mode, reg, r_m, rex_prefix, wbit, LONG_OPND, 0);
25107c478bd9Sstevel@tonic-gate 		break;
25117c478bd9Sstevel@tonic-gate 
25127c478bd9Sstevel@tonic-gate 	/* SIMD memory or xmm reg operand to xmm reg		*/
25137c478bd9Sstevel@tonic-gate 	case XMM:
25147c478bd9Sstevel@tonic-gate 	case XMMO:
25157c478bd9Sstevel@tonic-gate 	case XMMXIMPL:
25167c478bd9Sstevel@tonic-gate 		wbit = XMM_OPND;
25177c478bd9Sstevel@tonic-gate 		STANDARD_MODRM(x, mode, reg, r_m, rex_prefix, wbit, 0);
25187c478bd9Sstevel@tonic-gate 
25197c478bd9Sstevel@tonic-gate 		if (dp->it_adrmode == XMMXIMPL && mode != REG_ONLY)
25207c478bd9Sstevel@tonic-gate 			goto error;
25217c478bd9Sstevel@tonic-gate 
25227c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
25237c478bd9Sstevel@tonic-gate 		/*
25247c478bd9Sstevel@tonic-gate 		 * movlps and movhlps share opcodes.  They differ in the
25257c478bd9Sstevel@tonic-gate 		 * addressing modes allowed for their operands.
25267c478bd9Sstevel@tonic-gate 		 * movhps and movlhps behave similarly.
25277c478bd9Sstevel@tonic-gate 		 */
25287c478bd9Sstevel@tonic-gate 		if (mode == REG_ONLY) {
25297c478bd9Sstevel@tonic-gate 			if (strcmp(dp->it_name, "movlps") == 0)
2530*d267098bSdmick 				(void) strncpy(x->d86_mnem, "movhlps", OPLEN);
25317c478bd9Sstevel@tonic-gate 			else if (strcmp(dp->it_name, "movhps") == 0)
2532*d267098bSdmick 				(void) strncpy(x->d86_mnem, "movlhps", OPLEN);
25337c478bd9Sstevel@tonic-gate 		}
25347c478bd9Sstevel@tonic-gate #endif
25357c478bd9Sstevel@tonic-gate 		if (dp->it_adrmode == XMMXIMPL)
25367c478bd9Sstevel@tonic-gate 			mode = 0;	/* change for memory access size... */
25377c478bd9Sstevel@tonic-gate 		break;
25387c478bd9Sstevel@tonic-gate 
25397c478bd9Sstevel@tonic-gate 	/* SIMD xmm reg to memory or xmm reg */
25407c478bd9Sstevel@tonic-gate 	case XMMS:
25417c478bd9Sstevel@tonic-gate 	case XMMOS:
25427c478bd9Sstevel@tonic-gate 	case XMMMS:
25437c478bd9Sstevel@tonic-gate 	case XMMOMS:
25447c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
25457c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
25467c478bd9Sstevel@tonic-gate 		if ((strcmp(dp->it_name, "movlps") == 0 ||
25477c478bd9Sstevel@tonic-gate 		    strcmp(dp->it_name, "movhps") == 0 ||
25487c478bd9Sstevel@tonic-gate 		    strcmp(dp->it_name, "movntps") == 0) &&
25497c478bd9Sstevel@tonic-gate 		    mode == REG_ONLY)
25507c478bd9Sstevel@tonic-gate 			goto error;
25517c478bd9Sstevel@tonic-gate #endif
25527c478bd9Sstevel@tonic-gate 		wbit = XMM_OPND;
25537c478bd9Sstevel@tonic-gate 		MIXED_MM(x, mode, reg, r_m, rex_prefix, wbit, XMM_OPND, 1);
25547c478bd9Sstevel@tonic-gate 		break;
25557c478bd9Sstevel@tonic-gate 
25567c478bd9Sstevel@tonic-gate 	/* SIMD memory to xmm reg */
25577c478bd9Sstevel@tonic-gate 	case XMMM:
25587c478bd9Sstevel@tonic-gate 	case XMMOM:
25597c478bd9Sstevel@tonic-gate 		wbit = XMM_OPND;
25607c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
25617c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
25627c478bd9Sstevel@tonic-gate 		if (mode == REG_ONLY) {
25637c478bd9Sstevel@tonic-gate 			if (strcmp(dp->it_name, "movhps") == 0)
2564*d267098bSdmick 				(void) strncpy(x->d86_mnem, "movlhps", OPLEN);
25657c478bd9Sstevel@tonic-gate 			else
25667c478bd9Sstevel@tonic-gate 				goto error;
25677c478bd9Sstevel@tonic-gate 		}
25687c478bd9Sstevel@tonic-gate #endif
25697c478bd9Sstevel@tonic-gate 		MIXED_MM(x, mode, reg, r_m, rex_prefix, wbit, XMM_OPND, 0);
25707c478bd9Sstevel@tonic-gate 		break;
25717c478bd9Sstevel@tonic-gate 
25727c478bd9Sstevel@tonic-gate 	/* SIMD memory or r32 to xmm reg			*/
25737c478bd9Sstevel@tonic-gate 	case XMM3MX:
25747c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
25757c478bd9Sstevel@tonic-gate 		MIXED_MM(x, mode, reg, r_m, rex_prefix, wbit, XMM_OPND, 0);
25767c478bd9Sstevel@tonic-gate 		break;
25777c478bd9Sstevel@tonic-gate 
25787c478bd9Sstevel@tonic-gate 	case XMM3MXS:
25797c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
25807c478bd9Sstevel@tonic-gate 		MIXED_MM(x, mode, reg, r_m, rex_prefix, wbit, XMM_OPND, 1);
25817c478bd9Sstevel@tonic-gate 		break;
25827c478bd9Sstevel@tonic-gate 
25837c478bd9Sstevel@tonic-gate 	/* SIMD memory or mm reg to xmm reg			*/
25847c478bd9Sstevel@tonic-gate 	case XMMOMX:
25857c478bd9Sstevel@tonic-gate 	/* SIMD mm to xmm */
25867c478bd9Sstevel@tonic-gate 	case XMMMX:
25877c478bd9Sstevel@tonic-gate 		wbit = MM_OPND;
25887c478bd9Sstevel@tonic-gate 		MIXED_MM(x, mode, reg, r_m, rex_prefix, wbit, XMM_OPND, 0);
25897c478bd9Sstevel@tonic-gate 		break;
25907c478bd9Sstevel@tonic-gate 
25917c478bd9Sstevel@tonic-gate 	/* SIMD memory or xmm reg to mm reg			*/
25927c478bd9Sstevel@tonic-gate 	case XMMXMM:
25937c478bd9Sstevel@tonic-gate 	case XMMOXMM:
25947c478bd9Sstevel@tonic-gate 	case XMMXM:
25957c478bd9Sstevel@tonic-gate 		wbit = XMM_OPND;
25967c478bd9Sstevel@tonic-gate 		MIXED_MM(x, mode, reg, r_m, rex_prefix, wbit, MM_OPND, 0);
25977c478bd9Sstevel@tonic-gate 		break;
25987c478bd9Sstevel@tonic-gate 
25997c478bd9Sstevel@tonic-gate 
26007c478bd9Sstevel@tonic-gate 	/* SIMD memory or xmm reg to r32			*/
26017c478bd9Sstevel@tonic-gate 	case XMMXM3:
26027c478bd9Sstevel@tonic-gate 		wbit = XMM_OPND;
26037c478bd9Sstevel@tonic-gate 		MIXED_MM(x, mode, reg, r_m, rex_prefix, wbit, LONG_OPND, 0);
26047c478bd9Sstevel@tonic-gate 		break;
26057c478bd9Sstevel@tonic-gate 
26067c478bd9Sstevel@tonic-gate 	/* SIMD xmm to r32					*/
26077c478bd9Sstevel@tonic-gate 	case XMMX3:
26087c478bd9Sstevel@tonic-gate 	case XMMOX3:
26097c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
26107c478bd9Sstevel@tonic-gate 		if (mode != REG_ONLY)
26117c478bd9Sstevel@tonic-gate 			goto error;
26127c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, &reg, &r_m);
26137c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, XMM_OPND, 0);
26147c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, reg, LONG_OPND, 1);
26157c478bd9Sstevel@tonic-gate 		NOMEM;
26167c478bd9Sstevel@tonic-gate 		break;
26177c478bd9Sstevel@tonic-gate 
26187c478bd9Sstevel@tonic-gate 	/* SIMD predicated memory or xmm reg with/to xmm reg */
26197c478bd9Sstevel@tonic-gate 	case XMMP:
26207c478bd9Sstevel@tonic-gate 	case XMMOPM:
26217c478bd9Sstevel@tonic-gate 		wbit = XMM_OPND;
26227c478bd9Sstevel@tonic-gate 		THREEOPERAND(x, mode, reg, r_m, rex_prefix, wbit, XMM_OPND, 1);
26237c478bd9Sstevel@tonic-gate 
26247c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
26257c478bd9Sstevel@tonic-gate 		/*
26267c478bd9Sstevel@tonic-gate 		 * cmpps and cmpss vary their instruction name based
26277c478bd9Sstevel@tonic-gate 		 * on the value of imm8.  Other XMMP instructions,
26287c478bd9Sstevel@tonic-gate 		 * such as shufps, require explicit specification of
26297c478bd9Sstevel@tonic-gate 		 * the predicate.
26307c478bd9Sstevel@tonic-gate 		 */
26317c478bd9Sstevel@tonic-gate 		if (dp->it_name[0] == 'c' &&
26327c478bd9Sstevel@tonic-gate 		    dp->it_name[1] == 'm' &&
26337c478bd9Sstevel@tonic-gate 		    dp->it_name[2] == 'p' &&
26347c478bd9Sstevel@tonic-gate 		    strlen(dp->it_name) == 5) {
26357c478bd9Sstevel@tonic-gate 			uchar_t pred = x->d86_opnd[0].d86_value & 0xff;
26367c478bd9Sstevel@tonic-gate 
26377c478bd9Sstevel@tonic-gate 			if (pred >= (sizeof (dis_PREDSUFFIX) / sizeof (char *)))
26387c478bd9Sstevel@tonic-gate 				goto error;
26397c478bd9Sstevel@tonic-gate 
2640*d267098bSdmick 			(void) strncpy(x->d86_mnem, "cmp", OPLEN);
2641*d267098bSdmick 			(void) strlcat(x->d86_mnem, dis_PREDSUFFIX[pred],
26427c478bd9Sstevel@tonic-gate 			    OPLEN);
2643*d267098bSdmick 			(void) strlcat(x->d86_mnem,
26447c478bd9Sstevel@tonic-gate 			    dp->it_name + strlen(dp->it_name) - 2,
26457c478bd9Sstevel@tonic-gate 			    OPLEN);
26467c478bd9Sstevel@tonic-gate 			x->d86_opnd[0] = x->d86_opnd[1];
26477c478bd9Sstevel@tonic-gate 			x->d86_opnd[1] = x->d86_opnd[2];
26487c478bd9Sstevel@tonic-gate 			x->d86_numopnds = 2;
26497c478bd9Sstevel@tonic-gate 		}
26507c478bd9Sstevel@tonic-gate #endif
26517c478bd9Sstevel@tonic-gate 		break;
26527c478bd9Sstevel@tonic-gate 
26537c478bd9Sstevel@tonic-gate 	/* immediate operand to accumulator */
26547c478bd9Sstevel@tonic-gate 	case IA:
26557c478bd9Sstevel@tonic-gate 		wbit = WBIT(opcode2);
26567c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, EAX_REGNO, wbit, 1);
26577c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, OPSIZE(opnd_size, wbit), 0);
26587c478bd9Sstevel@tonic-gate 		NOMEM;
26597c478bd9Sstevel@tonic-gate 		break;
26607c478bd9Sstevel@tonic-gate 
26617c478bd9Sstevel@tonic-gate 	/* memory or register operand to accumulator */
26627c478bd9Sstevel@tonic-gate 	case MA:
26637c478bd9Sstevel@tonic-gate 		wbit = WBIT(opcode2);
26647c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, NULL, &r_m);
26657c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, wbit, 0);
26667c478bd9Sstevel@tonic-gate 		break;
26677c478bd9Sstevel@tonic-gate 
26687c478bd9Sstevel@tonic-gate 	/* si register to di register used to reference memory		*/
26697c478bd9Sstevel@tonic-gate 	case SD:
26707c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
26717c478bd9Sstevel@tonic-gate 		dtrace_check_override(x, 0);
26727c478bd9Sstevel@tonic-gate 		x->d86_numopnds = 2;
26737c478bd9Sstevel@tonic-gate 		if (addr_size == SIZE64) {
2674dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[0].d86_opnd, "(%rsi)",
26757c478bd9Sstevel@tonic-gate 			    OPLEN);
2676dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[1].d86_opnd, "(%rdi)",
26777c478bd9Sstevel@tonic-gate 			    OPLEN);
26787c478bd9Sstevel@tonic-gate 		} else if (addr_size == SIZE32) {
2679dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[0].d86_opnd, "(%esi)",
26807c478bd9Sstevel@tonic-gate 			    OPLEN);
2681dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[1].d86_opnd, "(%edi)",
26827c478bd9Sstevel@tonic-gate 			    OPLEN);
26837c478bd9Sstevel@tonic-gate 		} else {
2684dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[0].d86_opnd, "(%si)",
26857c478bd9Sstevel@tonic-gate 			    OPLEN);
2686dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[1].d86_opnd, "(%di)",
26877c478bd9Sstevel@tonic-gate 			    OPLEN);
26887c478bd9Sstevel@tonic-gate 		}
26897c478bd9Sstevel@tonic-gate #endif
26907c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
26917c478bd9Sstevel@tonic-gate 		break;
26927c478bd9Sstevel@tonic-gate 
26937c478bd9Sstevel@tonic-gate 	/* accumulator to di register				*/
26947c478bd9Sstevel@tonic-gate 	case AD:
26957c478bd9Sstevel@tonic-gate 		wbit = WBIT(opcode2);
26967c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
26977c478bd9Sstevel@tonic-gate 		dtrace_check_override(x, 1);
26987c478bd9Sstevel@tonic-gate 		x->d86_numopnds = 2;
26997c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, EAX_REGNO, wbit, 0);
27007c478bd9Sstevel@tonic-gate 		if (addr_size == SIZE64)
2701dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[1].d86_opnd, "(%rdi)",
27027c478bd9Sstevel@tonic-gate 			    OPLEN);
27037c478bd9Sstevel@tonic-gate 		else if (addr_size == SIZE32)
2704dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[1].d86_opnd, "(%edi)",
27057c478bd9Sstevel@tonic-gate 			    OPLEN);
27067c478bd9Sstevel@tonic-gate 		else
2707dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[1].d86_opnd, "(%di)",
27087c478bd9Sstevel@tonic-gate 			    OPLEN);
27097c478bd9Sstevel@tonic-gate #endif
27107c478bd9Sstevel@tonic-gate 		break;
27117c478bd9Sstevel@tonic-gate 
27127c478bd9Sstevel@tonic-gate 	/* si register to accumulator				*/
27137c478bd9Sstevel@tonic-gate 	case SA:
27147c478bd9Sstevel@tonic-gate 		wbit = WBIT(opcode2);
27157c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
27167c478bd9Sstevel@tonic-gate 		dtrace_check_override(x, 0);
27177c478bd9Sstevel@tonic-gate 		x->d86_numopnds = 2;
27187c478bd9Sstevel@tonic-gate 		if (addr_size == SIZE64)
2719dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[0].d86_opnd, "(%rsi)",
27207c478bd9Sstevel@tonic-gate 			    OPLEN);
27217c478bd9Sstevel@tonic-gate 		else if (addr_size == SIZE32)
2722dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[0].d86_opnd, "(%esi)",
27237c478bd9Sstevel@tonic-gate 			    OPLEN);
27247c478bd9Sstevel@tonic-gate 		else
2725dc0093f4Seschrock 			(void) strlcat(x->d86_opnd[0].d86_opnd, "(%si)",
27267c478bd9Sstevel@tonic-gate 			    OPLEN);
27277c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, REG_ONLY, EAX_REGNO, wbit, 1);
27287c478bd9Sstevel@tonic-gate #endif
27297c478bd9Sstevel@tonic-gate 		break;
27307c478bd9Sstevel@tonic-gate 
27317c478bd9Sstevel@tonic-gate 	/*
27327c478bd9Sstevel@tonic-gate 	 * single operand, a 16/32 bit displacement
27337c478bd9Sstevel@tonic-gate 	 */
27347c478bd9Sstevel@tonic-gate 	case D:
27357c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
27367c478bd9Sstevel@tonic-gate 		dtrace_disp_opnd(x, wbit, OPSIZE(opnd_size, LONG_OPND), 0);
27377c478bd9Sstevel@tonic-gate 		NOMEM;
27387c478bd9Sstevel@tonic-gate 		break;
27397c478bd9Sstevel@tonic-gate 
27407c478bd9Sstevel@tonic-gate 	/* jmp/call indirect to memory or register operand		*/
27417c478bd9Sstevel@tonic-gate 	case INM:
27427c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
2743dc0093f4Seschrock 		(void) strlcat(x->d86_opnd[0].d86_prefix, "*", OPLEN);
27447c478bd9Sstevel@tonic-gate #endif
27457c478bd9Sstevel@tonic-gate 		dtrace_rex_adjust(rex_prefix, mode, NULL, &r_m);
27467c478bd9Sstevel@tonic-gate 		dtrace_get_operand(x, mode, r_m, LONG_OPND, 0);
27477c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
27487c478bd9Sstevel@tonic-gate 		break;
27497c478bd9Sstevel@tonic-gate 
27507c478bd9Sstevel@tonic-gate 	/*
27517c478bd9Sstevel@tonic-gate 	 * for long jumps and long calls -- a new code segment
27527c478bd9Sstevel@tonic-gate 	 * register and an offset in IP -- stored in object
27537c478bd9Sstevel@tonic-gate 	 * code in reverse order. Note - not valid in amd64
27547c478bd9Sstevel@tonic-gate 	 */
27557c478bd9Sstevel@tonic-gate 	case SO:
27567c478bd9Sstevel@tonic-gate 		dtrace_check_override(x, 1);
27577c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
27587c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, OPSIZE(opnd_size, LONG_OPND), 1);
27597c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
27607c478bd9Sstevel@tonic-gate 		x->d86_opnd[1].d86_mode = MODE_SIGNED;
27617c478bd9Sstevel@tonic-gate #endif
27627c478bd9Sstevel@tonic-gate 		/* will now get segment operand */
27637c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, 2, 0);
27647c478bd9Sstevel@tonic-gate 		break;
27657c478bd9Sstevel@tonic-gate 
27667c478bd9Sstevel@tonic-gate 	/*
27677c478bd9Sstevel@tonic-gate 	 * jmp/call. single operand, 8 bit displacement.
27687c478bd9Sstevel@tonic-gate 	 * added to current EIP in 'compofff'
27697c478bd9Sstevel@tonic-gate 	 */
27707c478bd9Sstevel@tonic-gate 	case BD:
27717c478bd9Sstevel@tonic-gate 		dtrace_disp_opnd(x, BYTE_OPND, 1, 0);
27727c478bd9Sstevel@tonic-gate 		NOMEM;
27737c478bd9Sstevel@tonic-gate 		break;
27747c478bd9Sstevel@tonic-gate 
27757c478bd9Sstevel@tonic-gate 	/* single 32/16 bit immediate operand			*/
27767c478bd9Sstevel@tonic-gate 	case I:
27777c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
27787c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, OPSIZE(opnd_size, LONG_OPND), 0);
27797c478bd9Sstevel@tonic-gate 		break;
27807c478bd9Sstevel@tonic-gate 
27817c478bd9Sstevel@tonic-gate 	/* single 8 bit immediate operand			*/
27827c478bd9Sstevel@tonic-gate 	case Ib:
27837c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
27847c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, 1, 0);
27857c478bd9Sstevel@tonic-gate 		break;
27867c478bd9Sstevel@tonic-gate 
27877c478bd9Sstevel@tonic-gate 	case ENTER:
27887c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
27897c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, 2, 0);
27907c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, 1, 1);
27917c478bd9Sstevel@tonic-gate 		switch (opnd_size) {
27927c478bd9Sstevel@tonic-gate 		case SIZE64:
27937c478bd9Sstevel@tonic-gate 			x->d86_memsize = (x->d86_opnd[1].d86_value + 1) * 8;
27947c478bd9Sstevel@tonic-gate 			break;
27957c478bd9Sstevel@tonic-gate 		case SIZE32:
27967c478bd9Sstevel@tonic-gate 			x->d86_memsize = (x->d86_opnd[1].d86_value + 1) * 4;
27977c478bd9Sstevel@tonic-gate 			break;
27987c478bd9Sstevel@tonic-gate 		case SIZE16:
27997c478bd9Sstevel@tonic-gate 			x->d86_memsize = (x->d86_opnd[1].d86_value + 1) * 2;
28007c478bd9Sstevel@tonic-gate 			break;
28017c478bd9Sstevel@tonic-gate 		}
28027c478bd9Sstevel@tonic-gate 
28037c478bd9Sstevel@tonic-gate 		break;
28047c478bd9Sstevel@tonic-gate 
28057c478bd9Sstevel@tonic-gate 	/* 16-bit immediate operand */
28067c478bd9Sstevel@tonic-gate 	case RET:
28077c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
28087c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, wbit, 2, 0);
28097c478bd9Sstevel@tonic-gate 		break;
28107c478bd9Sstevel@tonic-gate 
28117c478bd9Sstevel@tonic-gate 	/* single 8 bit port operand				*/
28127c478bd9Sstevel@tonic-gate 	case P:
28137c478bd9Sstevel@tonic-gate 		dtrace_check_override(x, 0);
28147c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, BYTE_OPND, 1, 0);
28157c478bd9Sstevel@tonic-gate 		NOMEM;
28167c478bd9Sstevel@tonic-gate 		break;
28177c478bd9Sstevel@tonic-gate 
28187c478bd9Sstevel@tonic-gate 	/* single operand, dx register (variable port instruction) */
28197c478bd9Sstevel@tonic-gate 	case V:
28207c478bd9Sstevel@tonic-gate 		x->d86_numopnds = 1;
28217c478bd9Sstevel@tonic-gate 		dtrace_check_override(x, 0);
28227c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
2823dc0093f4Seschrock 		(void) strlcat(x->d86_opnd[0].d86_opnd, "(%dx)", OPLEN);
28247c478bd9Sstevel@tonic-gate #endif
28257c478bd9Sstevel@tonic-gate 		NOMEM;
28267c478bd9Sstevel@tonic-gate 		break;
28277c478bd9Sstevel@tonic-gate 
28287c478bd9Sstevel@tonic-gate 	/*
28297c478bd9Sstevel@tonic-gate 	 * The int instruction, which has two forms:
28307c478bd9Sstevel@tonic-gate 	 * int 3 (breakpoint) or
28317c478bd9Sstevel@tonic-gate 	 * int n, where n is indicated in the subsequent
28327c478bd9Sstevel@tonic-gate 	 * byte (format Ib).  The int 3 instruction (opcode 0xCC),
28337c478bd9Sstevel@tonic-gate 	 * where, although the 3 looks  like an operand,
28347c478bd9Sstevel@tonic-gate 	 * it is implied by the opcode. It must be converted
28357c478bd9Sstevel@tonic-gate 	 * to the correct base and output.
28367c478bd9Sstevel@tonic-gate 	 */
28377c478bd9Sstevel@tonic-gate 	case INT3:
28387c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
28397c478bd9Sstevel@tonic-gate 		x->d86_numopnds = 1;
28407c478bd9Sstevel@tonic-gate 		x->d86_opnd[0].d86_mode = MODE_SIGNED;
28417c478bd9Sstevel@tonic-gate 		x->d86_opnd[0].d86_value_size = 1;
28427c478bd9Sstevel@tonic-gate 		x->d86_opnd[0].d86_value = 3;
28437c478bd9Sstevel@tonic-gate #endif
28447c478bd9Sstevel@tonic-gate 		NOMEM;
28457c478bd9Sstevel@tonic-gate 		break;
28467c478bd9Sstevel@tonic-gate 
28477c478bd9Sstevel@tonic-gate 	/* single 8 bit immediate operand			*/
28487c478bd9Sstevel@tonic-gate 	case INTx:
28497c478bd9Sstevel@tonic-gate 		dtrace_imm_opnd(x, BYTE_OPND, 1, 0);
28507c478bd9Sstevel@tonic-gate 		NOMEM;
28517c478bd9Sstevel@tonic-gate 		break;
28527c478bd9Sstevel@tonic-gate 
28537c478bd9Sstevel@tonic-gate 	/* an unused byte must be discarded */
28547c478bd9Sstevel@tonic-gate 	case U:
28557c478bd9Sstevel@tonic-gate 		if (x->d86_get_byte(x->d86_data) < 0)
28567c478bd9Sstevel@tonic-gate 			goto error;
28577c478bd9Sstevel@tonic-gate 		x->d86_len++;
28587c478bd9Sstevel@tonic-gate 		NOMEM;
28597c478bd9Sstevel@tonic-gate 		break;
28607c478bd9Sstevel@tonic-gate 
28617c478bd9Sstevel@tonic-gate 	case CBW:
28627c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
28637c478bd9Sstevel@tonic-gate 		if (opnd_size == SIZE16)
2864*d267098bSdmick 			(void) strlcat(x->d86_mnem, "cbtw", OPLEN);
28657c478bd9Sstevel@tonic-gate 		else if (opnd_size == SIZE32)
2866*d267098bSdmick 			(void) strlcat(x->d86_mnem, "cwtl", OPLEN);
28677c478bd9Sstevel@tonic-gate 		else
2868*d267098bSdmick 			(void) strlcat(x->d86_mnem, "cltq", OPLEN);
28697c478bd9Sstevel@tonic-gate #endif
28707c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
28717c478bd9Sstevel@tonic-gate 		NOMEM;
28727c478bd9Sstevel@tonic-gate 		break;
28737c478bd9Sstevel@tonic-gate 
28747c478bd9Sstevel@tonic-gate 	case CWD:
28757c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
28767c478bd9Sstevel@tonic-gate 		if (opnd_size == SIZE16)
2877*d267098bSdmick 			(void) strlcat(x->d86_mnem, "cwtd", OPLEN);
28787c478bd9Sstevel@tonic-gate 		else if (opnd_size == SIZE32)
2879*d267098bSdmick 			(void) strlcat(x->d86_mnem, "cltd", OPLEN);
28807c478bd9Sstevel@tonic-gate 		else
2881*d267098bSdmick 			(void) strlcat(x->d86_mnem, "cqtd", OPLEN);
28827c478bd9Sstevel@tonic-gate #endif
28837c478bd9Sstevel@tonic-gate 		wbit = LONG_OPND;
28847c478bd9Sstevel@tonic-gate 		NOMEM;
28857c478bd9Sstevel@tonic-gate 		break;
28867c478bd9Sstevel@tonic-gate 
28877c478bd9Sstevel@tonic-gate 	case XMMSFNC:
28887c478bd9Sstevel@tonic-gate 		/*
28897c478bd9Sstevel@tonic-gate 		 * sfence is sfence if mode is REG_ONLY.  If mode isn't
28907c478bd9Sstevel@tonic-gate 		 * REG_ONLY, mnemonic should be 'clflush'.
28917c478bd9Sstevel@tonic-gate 		 */
28927c478bd9Sstevel@tonic-gate 		dtrace_get_modrm(x, &mode, &reg, &r_m);
28937c478bd9Sstevel@tonic-gate 
28947c478bd9Sstevel@tonic-gate 		/* sfence doesn't take operands */
28957c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
28967c478bd9Sstevel@tonic-gate 		if (mode == REG_ONLY) {
2897*d267098bSdmick 			(void) strlcat(x->d86_mnem, "sfence", OPLEN);
28987c478bd9Sstevel@tonic-gate 		} else {
2899*d267098bSdmick 			(void) strlcat(x->d86_mnem, "clflush", OPLEN);
29007c478bd9Sstevel@tonic-gate 			dtrace_rex_adjust(rex_prefix, mode, &reg, &r_m);
29017c478bd9Sstevel@tonic-gate 			dtrace_get_operand(x, mode, r_m, BYTE_OPND, 0);
29027c478bd9Sstevel@tonic-gate 			NOMEM;
29037c478bd9Sstevel@tonic-gate 		}
29047c478bd9Sstevel@tonic-gate #else
29057c478bd9Sstevel@tonic-gate 		if (mode != REG_ONLY) {
29067c478bd9Sstevel@tonic-gate 			dtrace_rex_adjust(rex_prefix, mode, &reg, &r_m);
29077c478bd9Sstevel@tonic-gate 			dtrace_get_operand(x, mode, r_m, BYTE_OPND, 0);
29087c478bd9Sstevel@tonic-gate 			NOMEM;
29097c478bd9Sstevel@tonic-gate 		}
29107c478bd9Sstevel@tonic-gate #endif
29117c478bd9Sstevel@tonic-gate 		break;
29127c478bd9Sstevel@tonic-gate 
29137c478bd9Sstevel@tonic-gate 	/*
29147c478bd9Sstevel@tonic-gate 	 * no disassembly, the mnemonic was all there was so go on
29157c478bd9Sstevel@tonic-gate 	 */
29167c478bd9Sstevel@tonic-gate 	case NORM:
29177c478bd9Sstevel@tonic-gate 		if (dp->it_invalid32 && cpu_mode != SIZE64)
29187c478bd9Sstevel@tonic-gate 			goto error;
29197c478bd9Sstevel@tonic-gate 		NOMEM;
29207c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
29217c478bd9Sstevel@tonic-gate 	case IMPLMEM:
29227c478bd9Sstevel@tonic-gate 		break;
29237c478bd9Sstevel@tonic-gate 
29247c478bd9Sstevel@tonic-gate 	case XMMFENCE:
29257c478bd9Sstevel@tonic-gate 		/*
29267c478bd9Sstevel@tonic-gate 		 * Only the following exact byte sequences are allowed:
29277c478bd9Sstevel@tonic-gate 		 *
29287c478bd9Sstevel@tonic-gate 		 * 	0f ae e8	lfence
29297c478bd9Sstevel@tonic-gate 		 * 	0f ae f0	mfence
29307c478bd9Sstevel@tonic-gate 		 */
29317c478bd9Sstevel@tonic-gate 		if ((uint8_t)x->d86_bytes[x->d86_len - 1] != 0xe8 &&
29327c478bd9Sstevel@tonic-gate 		    (uint8_t)x->d86_bytes[x->d86_len - 1] != 0xf0)
29337c478bd9Sstevel@tonic-gate 			goto error;
29347c478bd9Sstevel@tonic-gate 
29357c478bd9Sstevel@tonic-gate 		break;
29367c478bd9Sstevel@tonic-gate 
29377c478bd9Sstevel@tonic-gate 
29387c478bd9Sstevel@tonic-gate 	/* float reg */
29397c478bd9Sstevel@tonic-gate 	case F:
29407c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
29417c478bd9Sstevel@tonic-gate 		x->d86_numopnds = 1;
2942dc0093f4Seschrock 		(void) strlcat(x->d86_opnd[0].d86_opnd, "%st(X)", OPLEN);
29437c478bd9Sstevel@tonic-gate 		x->d86_opnd[0].d86_opnd[4] = r_m + '0';
29447c478bd9Sstevel@tonic-gate #endif
29457c478bd9Sstevel@tonic-gate 		NOMEM;
29467c478bd9Sstevel@tonic-gate 		break;
29477c478bd9Sstevel@tonic-gate 
29487c478bd9Sstevel@tonic-gate 	/* float reg to float reg, with ret bit present */
29497c478bd9Sstevel@tonic-gate 	case FF:
29507c478bd9Sstevel@tonic-gate 		vbit = opcode2 >> 2 & 0x1;	/* vbit = 1: st -> st(i) */
29517c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
29527c478bd9Sstevel@tonic-gate 	case FFC:				/* case for vbit always = 0 */
29537c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
29547c478bd9Sstevel@tonic-gate 		x->d86_numopnds = 2;
2955dc0093f4Seschrock 		(void) strlcat(x->d86_opnd[1 - vbit].d86_opnd, "%st", OPLEN);
2956dc0093f4Seschrock 		(void) strlcat(x->d86_opnd[vbit].d86_opnd, "%st(X)", OPLEN);
29577c478bd9Sstevel@tonic-gate 		x->d86_opnd[vbit].d86_opnd[4] = r_m + '0';
29587c478bd9Sstevel@tonic-gate #endif
29597c478bd9Sstevel@tonic-gate 		NOMEM;
29607c478bd9Sstevel@tonic-gate 		break;
29617c478bd9Sstevel@tonic-gate 
29627c478bd9Sstevel@tonic-gate 	/* an invalid op code */
29637c478bd9Sstevel@tonic-gate 	case AM:
29647c478bd9Sstevel@tonic-gate 	case DM:
29657c478bd9Sstevel@tonic-gate 	case OVERRIDE:
29667c478bd9Sstevel@tonic-gate 	case PREFIX:
29677c478bd9Sstevel@tonic-gate 	case UNKNOWN:
29687c478bd9Sstevel@tonic-gate 		NOMEM;
29697c478bd9Sstevel@tonic-gate 	default:
29707c478bd9Sstevel@tonic-gate 		goto error;
29717c478bd9Sstevel@tonic-gate 	} /* end switch */
29727c478bd9Sstevel@tonic-gate 	if (x->d86_error)
29737c478bd9Sstevel@tonic-gate 		goto error;
29747c478bd9Sstevel@tonic-gate 
29757c478bd9Sstevel@tonic-gate done:
29767c478bd9Sstevel@tonic-gate #ifdef DIS_MEM
29777c478bd9Sstevel@tonic-gate 	/*
29787c478bd9Sstevel@tonic-gate 	 * compute the size of any memory accessed by the instruction
29797c478bd9Sstevel@tonic-gate 	 */
29807c478bd9Sstevel@tonic-gate 	if (x->d86_memsize != 0) {
29817c478bd9Sstevel@tonic-gate 		return (0);
29827c478bd9Sstevel@tonic-gate 	} else if (dp->it_stackop) {
29837c478bd9Sstevel@tonic-gate 		switch (opnd_size) {
29847c478bd9Sstevel@tonic-gate 		case SIZE16:
29857c478bd9Sstevel@tonic-gate 			x->d86_memsize = 2;
29867c478bd9Sstevel@tonic-gate 			break;
29877c478bd9Sstevel@tonic-gate 		case SIZE32:
29887c478bd9Sstevel@tonic-gate 			x->d86_memsize = 4;
29897c478bd9Sstevel@tonic-gate 			break;
29907c478bd9Sstevel@tonic-gate 		case SIZE64:
29917c478bd9Sstevel@tonic-gate 			x->d86_memsize = 8;
29927c478bd9Sstevel@tonic-gate 			break;
29937c478bd9Sstevel@tonic-gate 		}
29947c478bd9Sstevel@tonic-gate 	} else if (nomem || mode == REG_ONLY) {
29957c478bd9Sstevel@tonic-gate 		x->d86_memsize = 0;
29967c478bd9Sstevel@tonic-gate 
29977c478bd9Sstevel@tonic-gate 	} else if (dp->it_size != 0) {
29987c478bd9Sstevel@tonic-gate 		/*
29997c478bd9Sstevel@tonic-gate 		 * In 64 bit mode descriptor table entries
30007c478bd9Sstevel@tonic-gate 		 * go up to 10 bytes and popf/pushf are always 8 bytes
30017c478bd9Sstevel@tonic-gate 		 */
30027c478bd9Sstevel@tonic-gate 		if (x->d86_mode == SIZE64 && dp->it_size == 6)
30037c478bd9Sstevel@tonic-gate 			x->d86_memsize = 10;
30047c478bd9Sstevel@tonic-gate 		else if (x->d86_mode == SIZE64 && opcode1 == 0x9 &&
30057c478bd9Sstevel@tonic-gate 		    (opcode2 == 0xc || opcode2 == 0xd))
30067c478bd9Sstevel@tonic-gate 			x->d86_memsize = 8;
30077c478bd9Sstevel@tonic-gate 		else
30087c478bd9Sstevel@tonic-gate 			x->d86_memsize = dp->it_size;
30097c478bd9Sstevel@tonic-gate 
30107c478bd9Sstevel@tonic-gate 	} else if (wbit == 0) {
30117c478bd9Sstevel@tonic-gate 		x->d86_memsize = 1;
30127c478bd9Sstevel@tonic-gate 
30137c478bd9Sstevel@tonic-gate 	} else if (wbit == LONG_OPND) {
30147c478bd9Sstevel@tonic-gate 		if (opnd_size == SIZE64)
30157c478bd9Sstevel@tonic-gate 			x->d86_memsize = 8;
30167c478bd9Sstevel@tonic-gate 		else if (opnd_size == SIZE32)
30177c478bd9Sstevel@tonic-gate 			x->d86_memsize = 4;
30187c478bd9Sstevel@tonic-gate 		else
30197c478bd9Sstevel@tonic-gate 			x->d86_memsize = 2;
30207c478bd9Sstevel@tonic-gate 
30217c478bd9Sstevel@tonic-gate 	} else if (wbit == SEG_OPND) {
30227c478bd9Sstevel@tonic-gate 		x->d86_memsize = 4;
30237c478bd9Sstevel@tonic-gate 
30247c478bd9Sstevel@tonic-gate 	} else {
30257c478bd9Sstevel@tonic-gate 		x->d86_memsize = 8;
30267c478bd9Sstevel@tonic-gate 	}
30277c478bd9Sstevel@tonic-gate #endif
30287c478bd9Sstevel@tonic-gate 	return (0);
30297c478bd9Sstevel@tonic-gate 
30307c478bd9Sstevel@tonic-gate error:
30317c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
3032*d267098bSdmick 	(void) strlcat(x->d86_mnem, "undef", OPLEN);
30337c478bd9Sstevel@tonic-gate #endif
30347c478bd9Sstevel@tonic-gate 	return (1);
30357c478bd9Sstevel@tonic-gate }
30367c478bd9Sstevel@tonic-gate 
30377c478bd9Sstevel@tonic-gate #ifdef DIS_TEXT
30387c478bd9Sstevel@tonic-gate 
30397c478bd9Sstevel@tonic-gate /*
30407c478bd9Sstevel@tonic-gate  * Some instructions should have immediate operands printed
30417c478bd9Sstevel@tonic-gate  * as unsigned integers. We compare against this table.
30427c478bd9Sstevel@tonic-gate  */
30437c478bd9Sstevel@tonic-gate static char *unsigned_ops[] = {
30447c478bd9Sstevel@tonic-gate 	"or", "and", "xor", "test", "in", "out", "lcall", "ljmp",
30457c478bd9Sstevel@tonic-gate 	"rcr", "rcl", "ror", "rol", "shl", "shr", "sal", "psr", "psl",
30467c478bd9Sstevel@tonic-gate 	0
30477c478bd9Sstevel@tonic-gate };
30487c478bd9Sstevel@tonic-gate 
3049*d267098bSdmick 
30507c478bd9Sstevel@tonic-gate static int
30517c478bd9Sstevel@tonic-gate isunsigned_op(char *opcode)
30527c478bd9Sstevel@tonic-gate {
30537c478bd9Sstevel@tonic-gate 	char *where;
30547c478bd9Sstevel@tonic-gate 	int i;
30557c478bd9Sstevel@tonic-gate 	int is_unsigned = 0;
30567c478bd9Sstevel@tonic-gate 
30577c478bd9Sstevel@tonic-gate 	/*
30587c478bd9Sstevel@tonic-gate 	 * Work back to start of last mnemonic, since we may have
30597c478bd9Sstevel@tonic-gate 	 * prefixes on some opcodes.
30607c478bd9Sstevel@tonic-gate 	 */
30617c478bd9Sstevel@tonic-gate 	where = opcode + strlen(opcode) - 1;
30627c478bd9Sstevel@tonic-gate 	while (where > opcode && *where != ' ')
30637c478bd9Sstevel@tonic-gate 		--where;
30647c478bd9Sstevel@tonic-gate 	if (*where == ' ')
30657c478bd9Sstevel@tonic-gate 		++where;
30667c478bd9Sstevel@tonic-gate 
30677c478bd9Sstevel@tonic-gate 	for (i = 0; unsigned_ops[i]; ++i) {
30687c478bd9Sstevel@tonic-gate 		if (strncmp(where, unsigned_ops[i],
30697c478bd9Sstevel@tonic-gate 		    strlen(unsigned_ops[i])))
30707c478bd9Sstevel@tonic-gate 			continue;
30717c478bd9Sstevel@tonic-gate 		is_unsigned = 1;
30727c478bd9Sstevel@tonic-gate 		break;
30737c478bd9Sstevel@tonic-gate 	}
30747c478bd9Sstevel@tonic-gate 	return (is_unsigned);
30757c478bd9Sstevel@tonic-gate }
30767c478bd9Sstevel@tonic-gate 
3077*d267098bSdmick /*
3078*d267098bSdmick  * Print a numeric immediate into end of buf, maximum length buflen.
3079*d267098bSdmick  * The immediate may be an address or a displacement.  Mask is set
3080*d267098bSdmick  * for address size.  If the immediate is a "small negative", or
3081*d267098bSdmick  * if it's a negative displacement of any magnitude, print as -<absval>.
3082*d267098bSdmick  * Respect the "octal" flag.  "Small negative" is defined as "in the
3083*d267098bSdmick  * interval [NEG_LIMIT, 0)".
3084*d267098bSdmick  *
3085*d267098bSdmick  * Also, "isunsigned_op()" instructions never print negatives.
3086*d267098bSdmick  *
3087*d267098bSdmick  * Return whether we decided to print a negative value or not.
3088*d267098bSdmick  */
3089*d267098bSdmick 
3090*d267098bSdmick #define	NEG_LIMIT	-255
3091*d267098bSdmick enum {IMM, DISP};
3092*d267098bSdmick enum {POS, TRY_NEG};
3093*d267098bSdmick 
3094*d267098bSdmick static int
3095*d267098bSdmick print_imm(dis86_t *dis, uint64_t usv, uint64_t mask, char *buf,
3096*d267098bSdmick     size_t buflen, int disp, int try_neg)
3097*d267098bSdmick {
3098*d267098bSdmick 	int curlen;
3099*d267098bSdmick 	int64_t sv = (int64_t)usv;
3100*d267098bSdmick 	int octal = dis->d86_flags & DIS_F_OCTAL;
3101*d267098bSdmick 
3102*d267098bSdmick 	curlen = strlen(buf);
3103*d267098bSdmick 
3104*d267098bSdmick 	if (try_neg == TRY_NEG && sv < 0 &&
3105*d267098bSdmick 	    (disp || sv >= NEG_LIMIT) &&
3106*d267098bSdmick 	    !isunsigned_op(dis->d86_mnem)) {
3107*d267098bSdmick 		dis->d86_sprintf_func(buf + curlen, buflen - curlen,
3108*d267098bSdmick 		    octal ? "-0%llo" : "-0x%llx", (-sv) & mask);
3109*d267098bSdmick 		return (1);
3110*d267098bSdmick 	} else {
3111*d267098bSdmick 		if (disp == DISP)
3112*d267098bSdmick 			dis->d86_sprintf_func(buf + curlen, buflen - curlen,
3113*d267098bSdmick 			    octal ? "+0%llo" : "+0x%llx", usv & mask);
3114*d267098bSdmick 		else
3115*d267098bSdmick 			dis->d86_sprintf_func(buf + curlen, buflen - curlen,
3116*d267098bSdmick 			    octal ? "0%llo" : "0x%llx", usv & mask);
3117*d267098bSdmick 		return (0);
3118*d267098bSdmick 
3119*d267098bSdmick 	}
3120*d267098bSdmick }
3121*d267098bSdmick 
3122*d267098bSdmick 
3123*d267098bSdmick static int
3124*d267098bSdmick log2(int size)
3125*d267098bSdmick {
3126*d267098bSdmick 	switch (size) {
3127*d267098bSdmick 	case 1: return (0);
3128*d267098bSdmick 	case 2: return (1);
3129*d267098bSdmick 	case 4: return (2);
3130*d267098bSdmick 	case 8: return (3);
3131*d267098bSdmick 	}
3132*d267098bSdmick 	return (0);
3133*d267098bSdmick }
3134*d267098bSdmick 
31357c478bd9Sstevel@tonic-gate /* ARGSUSED */
31367c478bd9Sstevel@tonic-gate void
3137*d267098bSdmick dtrace_disx86_str(dis86_t *dis, uint_t mode, uint64_t pc, char *buf,
31387c478bd9Sstevel@tonic-gate     size_t buflen)
31397c478bd9Sstevel@tonic-gate {
3140*d267098bSdmick 	uint64_t reltgt = 0;
3141*d267098bSdmick 	uint64_t tgt = 0;
3142*d267098bSdmick 	int curlen;
3143*d267098bSdmick 	int (*lookup)(void *, uint64_t, char *, size_t);
31447c478bd9Sstevel@tonic-gate 	int i;
3145*d267098bSdmick 	int64_t sv;
3146*d267098bSdmick 	uint64_t usv, mask, save_mask, save_usv;
3147*d267098bSdmick 	static uint64_t masks[] =
3148*d267098bSdmick 	    {0xffU, 0xffffU, 0xffffffffU, 0xffffffffffffffffULL};
3149*d267098bSdmick 	save_usv = 0;
31507c478bd9Sstevel@tonic-gate 
3151*d267098bSdmick 	dis->d86_sprintf_func(buf, buflen, "%-6s ", dis->d86_mnem);
31527c478bd9Sstevel@tonic-gate 
3153dc0093f4Seschrock 	/*
3154dc0093f4Seschrock 	 * For PC-relative jumps, the pc is really the next pc after executing
3155dc0093f4Seschrock 	 * this instruction, so increment it appropriately.
3156dc0093f4Seschrock 	 */
3157dc0093f4Seschrock 	pc += dis->d86_len;
3158dc0093f4Seschrock 
31597c478bd9Sstevel@tonic-gate 	for (i = 0; i < dis->d86_numopnds; i++) {
31607c478bd9Sstevel@tonic-gate 		d86opnd_t *op = &dis->d86_opnd[i];
31617c478bd9Sstevel@tonic-gate 
31627c478bd9Sstevel@tonic-gate 		if (i != 0)
31637c478bd9Sstevel@tonic-gate 			(void) strlcat(buf, ",", buflen);
31647c478bd9Sstevel@tonic-gate 
31657c478bd9Sstevel@tonic-gate 		(void) strlcat(buf, op->d86_prefix, buflen);
31667c478bd9Sstevel@tonic-gate 
3167*d267098bSdmick 		/*
3168*d267098bSdmick 		 * sv is for the signed, possibly-truncated immediate or
3169*d267098bSdmick 		 * displacement; usv retains the original size and
3170*d267098bSdmick 		 * unsignedness for symbol lookup.
3171*d267098bSdmick 		 */
3172*d267098bSdmick 
3173*d267098bSdmick 		sv = usv = op->d86_value;
3174*d267098bSdmick 
3175*d267098bSdmick 		/*
3176*d267098bSdmick 		 * About masks: for immediates that represent
3177*d267098bSdmick 		 * addresses, the appropriate display size is
3178*d267098bSdmick 		 * the effective address size of the instruction.
3179*d267098bSdmick 		 * This includes MODE_OFFSET, MODE_IPREL, and
3180*d267098bSdmick 		 * MODE_RIPREL.  Immediates that are simply
3181*d267098bSdmick 		 * immediate values should display in the operand's
3182*d267098bSdmick 		 * size, however, since they don't represent addresses.
3183*d267098bSdmick 		 */
3184*d267098bSdmick 
3185*d267098bSdmick 		/* d86_addr_size is SIZEnn, which is log2(real size) */
3186*d267098bSdmick 		mask = masks[dis->d86_addr_size];
3187*d267098bSdmick 
3188*d267098bSdmick 		/* d86_value_size and d86_imm_bytes are in bytes */
3189*d267098bSdmick 		if (op->d86_mode == MODE_SIGNED ||
3190*d267098bSdmick 		    op->d86_mode == MODE_IMPLIED)
3191*d267098bSdmick 			mask = masks[log2(op->d86_value_size)];
31927c478bd9Sstevel@tonic-gate 
31937c478bd9Sstevel@tonic-gate 		switch (op->d86_mode) {
31947c478bd9Sstevel@tonic-gate 
31957c478bd9Sstevel@tonic-gate 		case MODE_NONE:
31967c478bd9Sstevel@tonic-gate 
31977c478bd9Sstevel@tonic-gate 			(void) strlcat(buf, op->d86_opnd, buflen);
31987c478bd9Sstevel@tonic-gate 			break;
31997c478bd9Sstevel@tonic-gate 
32007c478bd9Sstevel@tonic-gate 		case MODE_SIGNED:
32017c478bd9Sstevel@tonic-gate 		case MODE_IMPLIED:
32027c478bd9Sstevel@tonic-gate 		case MODE_OFFSET:
32037c478bd9Sstevel@tonic-gate 
3204*d267098bSdmick 			tgt = usv;
3205*d267098bSdmick 
32067c478bd9Sstevel@tonic-gate 			if (dis->d86_seg_prefix)
3207dc0093f4Seschrock 				(void) strlcat(buf, dis->d86_seg_prefix,
3208dc0093f4Seschrock 				    buflen);
32097c478bd9Sstevel@tonic-gate 
32107c478bd9Sstevel@tonic-gate 			if (op->d86_mode == MODE_SIGNED ||
3211*d267098bSdmick 			    op->d86_mode == MODE_IMPLIED) {
3212dc0093f4Seschrock 				(void) strlcat(buf, "$", buflen);
3213*d267098bSdmick 			}
32147c478bd9Sstevel@tonic-gate 
3215*d267098bSdmick 			if (print_imm(dis, usv, mask, buf, buflen,
3216*d267098bSdmick 			    IMM, TRY_NEG) &&
3217*d267098bSdmick 			    (op->d86_mode == MODE_SIGNED ||
3218*d267098bSdmick 			    op->d86_mode == MODE_IMPLIED)) {
3219*d267098bSdmick 
3220*d267098bSdmick 				/*
3221*d267098bSdmick 				 * We printed a negative value for an
3222*d267098bSdmick 				 * immediate that wasn't a
3223*d267098bSdmick 				 * displacement.  Note that fact so we can
3224*d267098bSdmick 				 * print the positive value as an
3225*d267098bSdmick 				 * annotation.
3226*d267098bSdmick 				 */
3227*d267098bSdmick 
3228*d267098bSdmick 				save_usv = usv;
3229*d267098bSdmick 				save_mask = mask;
32307c478bd9Sstevel@tonic-gate 			}
3231dc0093f4Seschrock 			(void) strlcat(buf, op->d86_opnd, buflen);
3232*d267098bSdmick 
32337c478bd9Sstevel@tonic-gate 			break;
32347c478bd9Sstevel@tonic-gate 
32357c478bd9Sstevel@tonic-gate 		case MODE_IPREL:
3236*d267098bSdmick 		case MODE_RIPREL:
32377c478bd9Sstevel@tonic-gate 
3238*d267098bSdmick 			reltgt = pc + sv;
3239*d267098bSdmick 
3240*d267098bSdmick 			switch (mode) {
3241*d267098bSdmick 			case SIZE16:
3242*d267098bSdmick 				reltgt = (uint16_t)reltgt;
32437c478bd9Sstevel@tonic-gate 				break;
3244*d267098bSdmick 			case SIZE32:
3245*d267098bSdmick 				reltgt = (uint32_t)reltgt;
32467c478bd9Sstevel@tonic-gate 				break;
32477c478bd9Sstevel@tonic-gate 			}
32487c478bd9Sstevel@tonic-gate 
3249*d267098bSdmick 			(void) print_imm(dis, usv, mask, buf, buflen,
3250*d267098bSdmick 			    DISP, TRY_NEG);
32517c478bd9Sstevel@tonic-gate 
3252*d267098bSdmick 			if (op->d86_mode == MODE_RIPREL)
3253*d267098bSdmick 				(void) strlcat(buf, "(%rip)", buflen);
3254*d267098bSdmick 			break;
3255*d267098bSdmick 		}
3256*d267098bSdmick 	}
32577c478bd9Sstevel@tonic-gate 
3258*d267098bSdmick 	/*
3259*d267098bSdmick 	 * The symbol lookups may result in false positives,
3260*d267098bSdmick 	 * particularly on object files, where small numbers may match
3261*d267098bSdmick 	 * the 0-relative non-relocated addresses of symbols.
3262*d267098bSdmick 	 */
32637c478bd9Sstevel@tonic-gate 
3264*d267098bSdmick 	lookup = dis->d86_sym_lookup;
3265*d267098bSdmick 	if (tgt != 0) {
3266*d267098bSdmick 		/* Print symbol, if found, for tgt */
3267*d267098bSdmick 		if (lookup(dis->d86_data, tgt, NULL, 0) == 0) {
3268*d267098bSdmick 			(void) strlcat(buf, "\t<", buflen);
3269*d267098bSdmick 			curlen = strlen(buf);
3270*d267098bSdmick 			lookup(dis->d86_data, tgt, buf + curlen,
3271*d267098bSdmick 			    buflen - curlen);
3272dc0093f4Seschrock 			(void) strlcat(buf, ">", buflen);
3273*d267098bSdmick 		}
32747c478bd9Sstevel@tonic-gate 
3275*d267098bSdmick 		/*
3276*d267098bSdmick 		 * If we printed a negative immediate above, print the
3277*d267098bSdmick 		 * positive in case our heuristic was unhelpful
3278*d267098bSdmick 		 */
3279*d267098bSdmick 		if (save_usv) {
3280*d267098bSdmick 			(void) strlcat(buf, "\t<", buflen);
3281*d267098bSdmick 			(void) print_imm(dis, save_usv, save_mask, buf, buflen,
3282*d267098bSdmick 			    IMM, POS);
3283*d267098bSdmick 			(void) strlcat(buf, ">", buflen);
32847c478bd9Sstevel@tonic-gate 		}
32857c478bd9Sstevel@tonic-gate 	}
3286*d267098bSdmick 
3287*d267098bSdmick 	if (reltgt != 0) {
3288*d267098bSdmick 		/* Print symbol or effective address for reltgt */
3289*d267098bSdmick 
3290*d267098bSdmick 		(void) strlcat(buf, "\t<", buflen);
3291*d267098bSdmick 		curlen = strlen(buf);
3292*d267098bSdmick 		lookup(dis->d86_data, reltgt, buf + curlen,
3293*d267098bSdmick 		    buflen - curlen);
3294*d267098bSdmick 		(void) strlcat(buf, ">", buflen);
3295*d267098bSdmick 	}
32967c478bd9Sstevel@tonic-gate }
32977c478bd9Sstevel@tonic-gate 
32987c478bd9Sstevel@tonic-gate #endif /* DIS_TEXT */
3299