程序员奶爸

遇到const修饰typedef所定义的类型时，请注意！

遇君阁 — Wed, 14 May 2008 04:55:00 GMT

有一次我在VS中遇到这样的一个编译错误，代码如下（程序1）：
typedef char * string;

class A
{
private:
char value[256];
public:
const string getValue() const
{
return value;
}
};

int _tmain(int argc, _TCHAR* argv[])
{
return 0;
}
编译错误：error C2440: 'return' : cannot convert from 'const char [256]' to 'const string'
为什么会有这样的编译错误呢？不是数组名可以转换成一个指针吗（此主题可参考），按此原理类推应该可以实现此类型转换。于是我改写代码（程序2）：
typedef char * string;

class A
{
private:
char value[256];
public:
const char * getValue() const
{
return value;
}
};

int _tmain(int argc, _TCHAR* argv[])
{
return 0;
}
这时编译这段代码却没有错误乐。为什么呢？原因在于在程序1中const从整体上修饰类型别名string（char *），那么就相当于char * const，表示char类型的指针为常量，所以就出现上述的编译错误。错误的根本原因就是我把typedef主观认为可以与#define等同，而typedef实际上却是定义一种类型的别名，而不只是简单的宏替换。这次经历也告诉我一个道理：不能凭主观或者说错误的观点进行推测，而应该认识到实践才是检验真理的唯一标准。

简单查看unicode编码对应的字符

遇君阁 — Mon, 12 May 2008 04:55:00 GMT

In word, you can use the ALT+X keyboard shortcut to enter the character directly in your document.

Type the Unicode (hexadecimal) value of the character.
Note The value string can also begin with U+.
Press ALT+X.
Microsoft Word replaces the string to the left of the insertion point with the character you specified.

请仔细权衡内存对齐

遇君阁 — Wed, 07 May 2008 03:28:00 GMT

字节对齐的目的是什么？
1.增加内存利用率
2.增加程序的运行效率
但这两点有时候在内存对齐时却是相互违背的。比如我们来对比下面的程序，在此之前声明一下我的环境，x86（P4）,VC 2005：
程序1
#pragma pack(4)
class A
{
public:
char a;
int aa;

};

程序2
#pragma pack(1)
class B
{
public:
char a;
int aa;

};
类A的size是8,而B的size是5,A相对于B来说浪费了内存空间，但同时我们还要看看对于A和B中的成员aa，aa的地址在类A中是可以被4整除（即：addr(A::aa)%4=0）,而aa在类B中由于内存对齐方式是1,所以aa的地址无法被4整除（即：addr(A::aa)%4!=0）．那么由于在x86（32位）上，从无法被4整除的地址边界去访问变量，会影响效率，具体原因已经超出了本文的讨论范围，以后用另一篇文章讨论．这里只放一个测试用例，如果有兴趣的朋友可以运行一下（VC 2005）：
测试用例１：
inline   unsigned   __int64   GetCycleCount(void)
{
      _asm         _emit   0x0F
      _asm         _emit   0x31
}

int _tmain(int argc, _TCHAR* argv[])
{
long long l = 3000000000000;

unsigned   __int64 begin = GetCycleCount();

for(long long i = 1000000000; i > 0; i--)
{
  // Empty the cache in CPU.
  l--;
  // Access the memory as the address can be divided by 4
  __asm
  {

   mov ecx,dword ptr [l]
  }
}

unsigned   __int64 end = GetCycleCount();
printf("The elapse time is:%I64d\n", end - begin);
return 0;
}
测试用例２：
inline   unsigned   __int64   GetCycleCount(void)
{
      _asm         _emit   0x0F
      _asm         _emit   0x31
}

int _tmain(int argc, _TCHAR* argv[])
{
long long l = 3000000000000;

unsigned   __int64 begin = GetCycleCount();

for(long long i = 1000000000; i > 0; i--)
{
  // Empty the cache in CPU.
  l--;
  // Access the memory as the address can not be divided by 4
  __asm
  {

   mov ecx,dword ptr [l+1]
  }
}

unsigned   __int64 end = GetCycleCount();
printf("The elapse time is:%I64d\n", end - begin);
return 0;
}
比较测试用例１与测试用例２打印出来的时间，你就可以从直观上得到访问奇地址时效率上的损失．
所以我的结论是：
在使用字节对齐时，请仔细考虑你要的是效率还是要的是内存，并在写程序时注意。

Effective C++ 目录重新划分

遇君阁 — Fri, 25 Apr 2008 06:24:00 GMT

详细设计时应该注意的Item：
条款03：尽可能使用const
Use const whenever possible.
条款18：让接口容易被正确使用，不易被误用
Make interfaces easy to use correctly and hard to use incorrectly.
条款19：设计class犹如设计type
Treat class design as type design.
条款20：宁以pass-by-reference-to-const替换pass-by-value
Prefer pass-by-reference-to-const to pass-by-value.
条款21：必须返回对象时，别妄想返回其reference
Don't try to return a reference when you must return an object.
条款22：将成员变量声明为private
Declare data members private.
条款23：宁以non-member、non-friend替换member函数
Prefer non-member non-friend functions to member functions.
条款24：若所有参数皆需类型转换，请为此采用non-member函数
Declare non-member functions when type conversions should apply to all parameters.
条款28：避免返回handles指向对象内部成分
Avoid returning "handles" to object internals.
条款32：确定你的public继承塑模出is-a关系
Make sure public inheritance models "is-a."
条款34：区分接口继承和实现继承
Differentiate between inheritance of interface and inheritance of implementation.
条款35：考虑virtual函数以外的其他选择
Consider alternatives to virtual functions.
条款36：绝不重新定义继承而来的non-virtual函数
Never redefine an inherited non-virtual function.
条款37：绝不重新定义继承而来的缺省参数值
Never redefine a function's inherited default parameter value.
条款38：通过复合塑模出has-a或"根据某物实现出"
Model "has-a" or "is-implemented-in-terms-of" through composition.
条款39：明智而审慎地使用private继承
Use private inheritance judiciously.
条款40：明智而审慎地使用多重继承
Use multiple inheritance judiciously.

写代码时应该注意的Item：
条款02：尽量以const, enum, inline替换 #define
Prefer consts,enums, and inlines to #defines.
条款04：确定对象被使用前已先被初始化
Make sure that objects are initialized before they're used.
条款05：了解C++ 默默编写并调用哪些函数
Know what functions C++ silently writes and calls.
条款06：若不想使用编译器自动生成的函数，就该明确拒绝
Explicitly disallow the use of compiler-generated functions you do not want.
条款07：为多态基类声明virtual析构函数
Declare destructors virtual in polymorphic base classes.
条款09：绝不在构造和析构过程中调用virtual函数
Never call virtual functions during construction or destruction.
条款10：令operator= 返回一个reference to *this
Have assignment operators return a reference to *this.
条款11：在operator= 中处理“自我赋值”
Handle assignment to self in operator=.
条款12：复制对象时勿忘其每一个成分
Copy all parts of an object.
条款25：考虑写出一个不抛异常的swap函数
Consider support for a non-throwing swap.
条款26：尽可能延后变量定义式的出现时间
Postpone variable definitions as long as possible.
条款27：尽量少做转型动作
Minimize casting.
条款30：透彻了解inlining的里里外外
Understand the ins and outs of inlining.
条款31：将文件间的编译依存关系降至最低
Minimize compilation dependencies between files.
条款33：避免遮掩继承而来的名称
Avoid hiding inherited names.

异常应该注意的Item：
条款08：别让异常逃离析构函数
Prevent exceptions from leaving destructors.
条款29：为“异常安全”而努力是值得的
Strive for exception-safe code.

资源管理
条款13：以对象管理资源
Use objects to manage resources.
条款14：在资源管理类中小心coping行为
Think carefully about copying behavior in resource-managing classes.
条款15：在资源管理类中提供对原始资源的访问
Provide access to raw resources in resource-managing classes.
条款16：成对使用new和delete时要采取相同形式
Use the same form in corresponding uses of new and delete.
条款17：以独立语句将newed对象置入智能指针
Store newed objects in smart pointers in standalone statements.
条款49：了解new-handler的行为
Understand the behavior of the new-handler.
条款50：了解new和delete的合理替换时机
Understand when it makes sense to replace new and delete.
条款51：编写new和delete时需固守常规
Adhere to convention when writing new and delete.
条款52：写了placement new也要写placement delete
Write placement delete if you write placement new.

模板与泛型编程
条款41：了解隐式接口和编译期多态
Understand implicit interfaces and compile-time polymorphism.
条款42：了解typename的双重意义
Understand the two meanings of typename.
条款43：学习处理模板化基类内的名称
Know how to access names in templatized base classes.
条款44：将与参数无关的代码抽离templates
Factor parameter-independent code out of templates.
条款45：运用成员函数模板接受所有兼容类型
Use member function templates to accept "all compatible types."
条款46：需要类型转换时请为模板定义非成员函数
Define non-member functions inside templates when type conversions are desired.
条款47：请使用traits classes表现类型信息
Use traits classes for information about types.
条款48：认识template元编程
Be aware of template metaprogramming.

杂项
条款01：视C++ 为一个语言联邦
View C++ as a federation of languages
条款53：不要轻忽编译器的警告
Pay attention to compiler warnings.
条款54：让自己熟悉包括TR1在内的标准程序库
Familiarize yourself with the standard library, including TR1.
条款55：让自己熟悉Boost
Familiarize yourself with Boost.

我个人感觉原来的目录容易理解，却不容易记忆。因为很大一部分的人看过Effective C++或者都还没有全部看完这本书，可他们都感觉虽然暂时理解了但没有办法一下把书里面所有的知识都应用于实践，所以我觉得如果是这样还不如在看过书以后对其进行纯记忆，以后再慢慢理解融会贯通进行使用，这样的效果更加明显。这也是我为什么重新划分原书目录的原因--暂时的理解不如先记忆后理解,希望对大家有用.

把数组名看成指针

遇君阁 — Thu, 24 Apr 2008 01:06:00 GMT

1．一维数组

如：int array[100];

array这个数组名可以转换成指向这个一维数组的指针，所以

int * p = array + 1; //array 转换成指针

int * foo(int * ptr);

{

return array; //array 转换成指针

}

foo(array); //array 转换成指针

2．二维数组

如：int array[10][20];

array这个数组名也可以转换成一个指针，但它的类型不是int **（指针的指针），而是一个指向一维数组的指针，这个一维数组拥有20个元素。所谓二维数组其实就是数组的数组，所以二维数组名解释为指向数组的指针是合理的。所以

int (*p)[20] = array; // array 转换成指向一维数组的指针

typedef int (*T)[20];

T foo(int ptr[][20])

{

return array; // array 转换成指向一维数组的指针

}

T foo1(int (*ptr)[20])

{

return array; // array 转换成指向一维数组的指针

}

foo(array); // array 转换成指向一维数组的指针

二维数组的定义可以参考： http://blog.vckbase.com/eyesonyhm/articles/23500.html

3．三维数组

同理……

注意：阿

数组≠指针。

数组名是一个常量指针。

[转/自用]Intel 奔腾指令速查手册

遇君阁 — Wed, 23 Apr 2008 05:00:00 GMT

Intel奔腾指令速查手册

资料来源：IA-32 Intel Architecture Software Developer Manual Volume 2 : Instruction Set Reference

指令名称	指令形式	机器码	说明
ES:	ES:	26	ES段跨越前缀
CS:	CS:	2E	CS段跨越前缀
SS:	SS:	36	SS段跨越前缀
DS:	DS:	3E	DS段跨越前缀
FS:	FS:	64	FS段跨越前缀
GS:	GS:	65	GS段跨越前缀
Opsize:	Opsize:	66	操作数类型跨越前缀
Address:	Address:	67	地址类型跨越前缀

点击这里：查看下表中所使用符号的说明

指令名称	指令形式	机器码	标志位(设置/测试)	说明	应用举例
AAA	AAA	37	设置 AF CF	加法后的ASCII码调整AL	AAA
AAD	AAD	D5 0A 或 D5 ib	设置 SF ZF PF	除法前的ASCII码调整AX	AAD
AAM	AAM	D4 0A 或 D4 ib	设置 PF SF ZF	乘法后的ASCII码调整AX	AAM
AAS	AAS	3F	设置 AF CF	减法后的ASCII码调整AL	AAS
ADC	ADC AL, imm8	14 ib	设置 AF CF OF SF PF ZF	带进位加法	ADC AL, 1F
	ADC AX, imm16	15 iw			ADC AX, 4F80
	ADC EAX, imm32	15 id			ADC EAX, 00004F80
	ADC r/m8, imm8	80 /2 ib			ADC BYTE PTR [006387EA], 39
	ADC r/m16,imm16	81 /2 iw			ADC WORD PTR [006387EA], 1039
	ADC r/m32,imm32	81 /2 id			ADC DWORD PTR [006387EA], 00001039
	ADC r/m16,imm8	83 /2 ib			ADC WORD PTR [006387EA], 39
	ADC r/m32,imm8	83 /2 ib			ADC DWORD PTR [006387EA], 39
	ADC r/m8,r8	10 /r			ADC [006387EA], AL
	ADC r/m16,r16	11 /r			ADC [006387EA], AX
	ADC r/m32,r32	11 / r			ADC [006387EA], EAX
	ADC r8,r/m8	12 /r			ADC AL, [006387EA]
	ADC r16,r/m16	13 /r			ADC AX, [006387EA]
	ADC r32,r/m32	13 /r			ADC EAX, [006387EA]
ADD	ADD AL, imm8	04 ib	设置 AF CF OF SF PF ZF	加法	ADD AL, 1F
	ADD AX, imm16	05 iw			ADD AX, 4F80
	ADD EAX, imm32	05 id			ADD EAX, 00004F80
	ADD r/m8, imm8	80 /0 ib			ADD BYTE PTR [006387EA], 39
	ADD r/m16,imm16	81 /0 iw			ADD WORD PTR [006387EA], 1039
	ADD r/m32,imm32	81 /0 id			ADD DWORD PTR [006387EA], 00001039
	ADD r/m16,imm8	83 /0 ib			ADD WORD PTR [006387EA], 39
	ADD r/m32,imm8	83 /0 ib			ADD DWORD PTR [006387EA], 39
	ADD r/m8,r8	00 /r			ADD [006387EA], AL
	ADD r/m16,r16	01 /r			ADD [006387EA], AX
	ADD r/m32,r32	01 / r			ADD [006387EA], EAX
	ADD r8,r/m8	02 /r			ADD AL, [006387EA]
	ADD r16,r/m16	03 /r			ADD AX, [006387EA]
	ADD r32,r/m32	03 /r			ADD EAX, [006387EA]
AND	AND AL, imm8	24 ib	设置 CF OF PF SF ZF	逻辑与	AND AL, 1F
	AND AX, imm16	25 iw			AND AX, 4F80
	AND EAX, imm32	25 id			AND EAX, 00004F80
	AND r/m8, imm8	80 /4 ib			AND BYTE PTR [006387EA], 39
	AND r/m16,imm16	81 /4 iw			AND WORD PTR [006387EA], 1039
	AND r/m32,imm32	81 /4 id			AND DWORD PTR [006387EA], 00001039
	AND r/m16,imm8	83 /4 ib			AND WORD PTR [006387EA], 39
	AND r/m32,imm8	83 /4 ib			AND DWORD PTR [006387EA], 39
	AND r/m8,r8	20 /r			AND BYTE PTR [006387EA], AL
	AND r/m16,r16	21 /r			AND WORD PTR [006387EA], AX
	AND r/m32,r32	21 /r			AND DWORD PTR [006387EA], EAX
	AND r8,r/m8	22 /r			AND AL, [006387EA]
	AND r16,r/m16	23 /r			AND AX, [006387EA]
	AND r32,r/m32	23 /r			AND EAX, [006387EA]
ARPL	ARPL r/m16,r16	63 /r	设置 ZF	调整请求特权级 (286+ PM)	ARPL AX, BX ；如果AX的RPL小于BX的RPL，则改为BX的RPL，且ZF置1，否则ZF清0
BOUND	BOUND r16,m16&16	62 /r	不影响标志位	越界检查 (80188+)	BOUND AX, [006387EA] ；如果AX不在[006387EA]及[006387EA+2]的值中间，则产生异常5
BOUND	BOUND r32,m32&32	62 /r	不影响标志位	越界检查 (80188+)	BOUND EAX, [006387EA] ；如果EAX不在[006387EA]及[006387EA+4]的值中间，则产生异常5
BSF	BSF r16,r/m16	0F BC	设置 ZF	从低到高扫描目标，查找对应为1的位 (386+)	BSF AX, BX ；把BX由低到高第一个1的位置送AX，如全0则ZF置1，否则ZF清0
BSF	BSF r32,r/m32	0F BC	设置 ZF	从低到高扫描目标，查找对应为1的位 (386+)	BSF EAX, EBX ；把EBX由低到高第一个1的位置送EAX，如全0则ZF置1，否则ZF清0
BSR	BSR r16,r/m16	0F BD	设置 ZF	从高到低扫描目标，查找对应为1的位 (386+)	BSR AX, BX ；把BX由高到低第一个1的位置送AX，如全0则ZF置1，否则ZF清0
BSR	BSR r32,r/m32	0F BD	设置 ZF	从高到低扫描目标，查找对应为1的位 (386+)	BSR EAX, EBX ；把EBX由高到低第一个1的位置送EAX，如全0则ZF置1，否则ZF清0
BSWAP	BSWAP reg32	0F C8+rd	不影响标志位	32位寄存器高低字节交换(486+)	BSWAP EAX
BT	BT r/m16,r16	0F A3	设置 CF	测试目标的指定位 (386+)	BT AX, BX ；如果AX中BX指定的位为1，则CF置1，否则CF清0
	BT r/m32,r32	0F A3			BT EAX, EBX ；如果EAX中EBX指定的位为1，则CF置1，否则CF清0
	BT r/m16,imm8	0F BA /4			BT AX, 01 ；如果AX中01位为1，则CF置1，否则CF清0
	BT r/m32,imm8	0F BA /4			BT EAX, 01 ；如果EAX中01位为1，则CF置1，否则CF清0
BTC	BTC r/m16,r16	0F BB	设置 CF	将目标指定位取反 (386+)	BTC AX, BX ；将AX中BX指定的位取反，CF存放指定位并取反位
	BTC r/m32,r32	0F BB			BTC EAX, EBX ；将EAX中EBX指定的位取反，CF存放指定位并取反
	BTC r/m16,imm8	0F BA /7			BTC AX, 01 ；将AX中01位取反，CF存放指定位并取反
	BTC r/m32,imm8	0F BA /7			BTC EAX, 01 ；将EAX中01位取反，CF存放指定位并取反
BTR	BTR r/m16,r16	0F B3	设置 CF	将目标指定位清0 (386+)	BTR AX, BX ；将AX中BX指定的位清0，CF存放指定位并清0
	BTR r/m32,r32	0F B3			BTR EAX, EBX ；将EAX中EBX指定的位清0，CF存放指定位并清0
	BTR r/m16,imm8	0F BA /6			BTR AX, 01 ；将AX中01位清0，CF存放指定位并清0
	BTR r/m32,imm8	0F BA /6			BTR EAX, 01 ；将EAX中01位清0，CF存放指定位并清0
BTS	BTS r/m16,r16	0F AB	设置 CF	将目标指定位置1 (386+)	BTS AX, BX ；将AX中BX指定的位置1，CF存放指定位并置1
	BTS r/m32,r32	0F AB			BTS EAX, EBX ；将EAX中EBX指定的位置1，CF存放指定位并置1
	BTS r/m16,imm8	0F BA /5			BTS AX, 01 ；将AX中01位置1，CF存放指定位并置1
	BTS r/m32,imm8	0F BA /5			BTS EAX, 01 ；将EAX中01位置1，CF存放指定位并置1
CALL	CALL rel16	E8 cw	不影响标志位	子程序调用(16位相对寻址)
	CALL rel32	E8 cd		子程序调用(32位相对寻址)
	CALL r/m16	FF /2		子程序调用(16位间接寻址)
	CALL r/m32	FF /2		子程序调用(32位间接寻址)
	CALL ptr16:16	9A cd		子程序调用(直接绝对寻址)
	CALL ptr16:32	9A cp		子程序调用(直接绝对寻址)
	CALL m16:16	FF /3		子程序调用(间接绝对寻址)
	CALL m16:32	FF /3		子程序调用(间接绝对寻址)
CBW	CBW	98	不影响标志位	将AL值带符号扩展到AX	CBW
CDQ	CDQ	99	不影响标志位	将EAX值带符号扩展到EDX：EAX	CDQ
CLD	CLD	FC	设置 DF	清除方向位(DF)标志	CLD
CLI	CLI	FA	设置 IF	清除中断允许位(IF)标志	CLD
CLTS	CLTS	0F 06	不影响标志位	清除任务开关标志(TSF)	CLTS
CMC	CMC	F5	设置 CF	进位标志取反	CMC
CMOVcc	CMOVA r16, r/m16	0F 47 /r	高于(CF=0 and ZF=0)	条件传送指令	CMOVA AX, BX
	CMOVA r32, r/m32	0F 47 /r	高于(CF=0 and ZF=0)		CMOVA EAX, EBX
	CMOVAE r16, r/m16	0F 43 /r	高于等于(CF=0)		CMOVAE AX, BX
	CMOVAE r32, r/m32	0F 43 /r	高于等于(CF=0)		CMOVAE EAX, EBX
	CMOVB r16, r/m16	0F 42 /r	低于(CF=1)		CMOVB AX, BX
	CMOVB r32, r/m32	0F 42 /r	低于(CF=1)		CMOVB EAX, EBX
	CMOVBE r16, r/m16	0F 46 /r	低于等于(CF=1 or ZF=1)		CMOVBE AX, BX
	CMOVBE r32, r/m32	0F 46 /r	低于等于(CF=1 or ZF=1)		CMOVBE EAX, EBX
	CMOVC r16, r/m16	0F 42 /r	有进位(CF=1)		CMOVC AX, BX
	CMOVC r32, r/m32	0F 42 /r	有进位(CF=1)		CMOVC EAX, EBX
	CMOVE r16, r/m16	0F 44 /r	等于(ZF=1)		CMOVE AX, BX
	CMOVE r32, r/m32	0F 44 /r	等于(ZF=1)		CMOVE EAX, EBX
	CMOVG r16, r/m16	0F 4F /r	大于(ZF=0 and SF=OF)		CMOVG AX, BX
	CMOVG r32, r/m32	0F 4F /r	大于(ZF=0 and SF=OF)		CMOVG EAX, EBX
	CMOVGE r16, r/m16	0F 4D /r	大于等于(SF=OF)		CMOVGE AX, BX
	CMOVGE r32, r/m32	0F 4D /r	大于等于(SF=OF)		CMOVGE EAX, EBX
	CMOVL r16, r/m16	0F 4C /r	小于(SF<>OF)		CMOVL AX, BX
	CMOVL r32, r/m32	0F 4C /r	小于(SF<>OF)		CMOVL EAX, EBX
	CMOVLE r16, r/m16	0F 4E /r	小于等于(ZF=1 or SF<>OF)		CMOVLE AX, BX
	CMOVLE r32, r/m32	0F 4E /r	小于等于(ZF=1 or SF<>OF)		CMOVLE EAX, EBX
	CMOVNA r16, r/m16	0F 46 /r	不高于(CF=1 or ZF=1)		CMOVNA AX, BX
	CMOVNA r32, r/m32	0F 46 /r	不高于(CF=1 or ZF=1)		CMOVNA EAX, EBX
	CMOVNAE r16, r/m16	0F 42 /r	不高等于(CF=1)		CMOVNAE AX, BX
	CMOVNAE r32, r/m32	0F 42 /r	不高等于(CF=1)		CMOVNAE EAX, EBX
	CMOVNB r16, r/m16	0F 43 /r	不低于(CF=0)		CMOVNB AX, BX
	CMOVNB r32, r/m32	0F 43 /r	不低于(CF=0)		CMOVNB EAX, EBX
	CMOVNBE r16, r/m16	0F 47 /r	不低等于(CF=0 and ZF=0)		CMOVNBE AX, BX
	CMOVNBE r32, r/m32	0F 47 /r	不低等于(CF=0 and ZF=0)		CMOVNBE EAX, EBX
	CMOVNC r16, r/m16	0F 43 /r	无进位(CF=0)		CMOVNC AX, BX
	CMOVNC r32, r/m32	0F 43 /r	无进位(CF=0)		CMOVNC EAX, EBX
	CMOVNE r16, r/m16	0F 45 /r	不等于(ZF=0)		CMOVNE AX, BX
	CMOVNE r32, r/m32	0F 45 /r	不等于(ZF=0)		CMOVNE EAX, EBX
	CMOVNG r16, r/m16	0F 4E /r	不大于(ZF=1 or SF<>OF)		CMOVNG AX, BX
	CMOVNG r32, r/m32	0F 4E /r	不大于(ZF=1 or SF<>OF)		CMOVNG EAX, EBX
	CMOVNGE r16, r/m16	0F 4C /r	不大等于(SF<>OF)		CMOVNGE AX, BX
	CMOVNGE r32, r/m32	0F 4C /r	不大等于(SF<>OF)		CMOVNGE EAX, EBX
	CMOVNL r16, r/m16	0F 4D /r	不小于(SF=OF)		CMOVNL AX, BX
	CMOVNL r32, r/m32	0F 4D /r	不小于(SF=OF)		CMOVNL EAX, EBX
	CMOVNLE r16, r/m16	0F 4F /r	不小等于(ZF=0 and SF=OF)		CMOVNLE AX, BX
	CMOVNLE r32, r/m32	0F 4F /r	不小等于(ZF=0 and SF=OF)		CMOVNLE EAX, EBX
	CMOVNO r16, r/m16	0F 41 /r	无溢出(OF=0)		CMOVNO AX, BX
	CMOVNO r32, r/m32	0F 41 /r	无溢出(OF=0)		CMOVNO EAX, EBX
	CMOVNP r16, r/m16	0F 4B /r	非偶数(PF=0)		CMOVNP AX, BX
	CMOVNP r32, r/m32	0F 4B /r	非偶数(PF=0)		CMOVNP EAX, EBX
	CMOVNS r16, r/m16	0F 49 /r	非负数(SF=0)		CMOVNS AX, BX
	CMOVNS r32, r/m32	0F 49 /r	非负数(SF=0)		CMOVNS EAX, EBX
	CMOVNZ r16, r/m16	0F 45 /r	非零(ZF=0)		CMOVNZ AX, BX
	CMOVNZ r32, r/m32	0F 45 /r	非零(ZF=0)		CMOVNZ EAX, EBX
	CMOVO r16, r/m16	0F 40 /r	溢出(OF=1)		CMOVO AX, BX
	CMOVO r32, r/m32	0F 40 /r	溢出(OF=1)		CMOVO EAX, EBX
	CMOVP r16, r/m16	0F 4A /r	偶数(PF=1)		CMOVP AX, BX
	CMOVP r32, r/m32	0F 4A /r	偶数(PF=1)		CMOVP EAX, EBX
	CMOVPE r16, r/m16	0F 4A /r	偶数(PF=1)		CMOVPE AX, BX
	CMOVPE r32, r/m32	0F 4A /r	偶数(PF=1)		CMOVPE EAX, EBX
	CMOVPO r16, r/m16	0F 4B /r	奇数(PF=0)		CMOVPO AX, BX
	CMOVPO r32, r/m32	0F 4B /r	奇数(PF=0)		CMOVPO EAX, EBX
	CMOVS r16, r/m16	0F 48 /r	负数(SF=1)		CMOVS AX, BX
	CMOVS r32, r/m32	0F 48 /r	负数(SF=1)		CMOVS EAX, EBX
	CMOVZ r16, r/m16	0F 44 /r	为零(ZF=1)		CMOVZ AX, BX
	CMOVZ r32, r/m32	0F 44 /r	为零(ZF=1)		CMOVZ EAX, EBX
CMP	CMP AL, imm8	3C ib	设置 AF CF OF PF SF ZF	比较大小，然后设置标志位	CMP AL, 1F
	CMP AX, imm16	3D iw			CMP AX, 4F80
	CMP EAX, imm32	3D id			CMP EAX, 00004F80
	CMP r/m8, imm8	80 /7 ib			CMP BYTE PTR [006387EA], 39
	CMP r/m16,imm16	81 /7 iw			CMP WORD PTR [006387EA], 1039
	CMP r/m32,imm32	81 /7 id			CMP DWORD PTR [006387EA], 00001039
	CMP r/m16,imm8	83 /7 ib			CMP WORD PTR [006387EA], 39
	CMP r/m32,imm8	83 /7 ib			CMP DWORD PTR [006387EA], 39
	CMP r/m8,r8	38 /r			CMP BYTE PTR [006387EA], AL
	CMP r/m16,r16	39 /r			CMP WORD PTR [006387EA], AX
	CMP r/m32,r32	39 / r			CMP DWORD PTR [006387EA], EAX
	CMP r8,r/m8	3A /r			CMP AL, [006387EA]
	CMP r16,r/m16	3B /r			CMP AX, [006387EA]
	CMP r32,r/m32	3B /r			CMP EAX, [006387EA]
CMPS	CMPS m8, m8	A6	设置 AF CF OF PF SF ZF	比较字符串，每次比较1个字节	CMPS STRING1, STRING2 ；源串DS:(E)SI，目的串：ES:(E)DI
	CMPS m16, m16	A7		比较字符串，每次比较1个字	CMPS STRING1, STRING2 ；源串DS:(E)SI，目的串：ES:(E)DI
	CMPS m32, m32	A7		比较字符串，每次比较1个双字	CMPS STRING1, STRING2 ；源串DS:(E)SI，目的串：ES:(E)DI (386+)
	CMPSB	A6		比较字符串，每次比较1个字节	CMPSB ；源串DS:(E)SI，目的串：ES:(E)DI
	CMPSW	A7		比较字符串，每次比较1个字	CMPSW ；源串DS:(E)SI，目的串：ES:(E)DI
	CMPSD	A7		比较字符串，每次比较1个双字	CMPSD ；源串DS:(E)SI，目的串：ES:(E)DI (386+)
CMPXCHG	CMPXCHG r/m8,r8	0F B0 /r	设置 AF CF OF PF SF ZF	比较交换 (486+)	CMPXCHG BL,CL ；如果AL与BL相等，则CL送BL且ZF置1；否则BL送CL，且ZF清0
	CMPXCHG r/m16,r16	0F B1 /r			CMPXCHG BX,CX ；如果AX与BX相等，则CX送BX且ZF置1；否则BX送CX，且ZF清0
	CMPXCHG r/m32,r32	0F B1 /r			CMPXCHG EBX,ECX ；如果EAX与EBX相等，则ECX送EBX且ZF置1；否则EBX送ECX，且ZF清0
CMPXCHG8B	CMPXCHG8B m64	0F C7 /1 m64	设置 ZF	比较交换 (486+)	CMPXCHG [ESI] ；比较EDX：EAX与64位的目标，如果相等则ECX：EBX送往目标且ZF置1，否则目标送EDX：EAX且ZF清0
CPUID	CPUID	0F A2	不影响标志位	CPU标识送EAX、EBX、ECX、EDX	CPUID
CWD	CWD	99	不影响标志位	将AX带符号扩展到DX：AX	CWD
CWDE	CWDE	98	不影响标志位	将AX带符号扩展到EAX	CWDE
DAA	DAA	27	设置 AF CF PF SF ZF	加法后的10进制调整AL	DAA
DAS	DAS	2F	设置 AF CF PF SF ZF	减法后的10进制调整AL	DAS
DEC	DEC r/m8	FE /1	设置 AF OF PF SF ZF	目标减1	DEC BYTE PTR [00458A90]
	DEC r/m16	FF /1			DEC WORD PTR [00458A90]
	DEC r/m32	FF /1			DEC DWORD PTR [00458A90]
	DEC r16	48 +rw			DEC AX
	DEC r32	48 +rd			DEC EAX
DIV	DIV r/m8	F6 /6	AF CF OF PF SF ZF 未定义	无符号除法	DIV BL ；AX除以BL，商在AL中，余数在AH中
	DIV r/m16	F6 /7			DIV BX ；DX：AX除以BX，商在AX中，余数在DX中
	DIV r/m32	F6 /7			DIV EBX；EDX：EAX除以BX，商在EAX中，余数在EDX中
EMMS	EMMS	0F 77	不影响标志位	清空MMX状态	EMMS
ENTER	ENTER imm16,0	C8 iw 00	不影响标志位	为子程序建立堆栈框架，imm16指定要分配的堆栈大小，另外一个操作数指明子程序的等级 (80188+)	ENTER 12,0
	ENTER imm16,1	C8 iw 01			ENTER 12,1
	ENTER imm16,imm8	C8 iw ib			DENTER 12,4
ESC	ESC 0	D8h xxh	不影响标志位	处理器放弃总线	ESC 0
	ESC 1	D9h xxh			ESC 1
	ESC 2	DAh xxh			ESC 2
	ESC 3	DBh xxh			ESC 3
	ESC 4	DCh xxh			ESC 4
	ESC 5	DDh xxh			ESC 5
	ESC 6	DEh xxh			ESC 6
	ESC 7	DFh xxh			ESC 7
F2XM1	F2XM1	D9 F0	设置C1 (C0, C2, C3未定义)	ST(0)←(2**ST(0) - 1)	F2XM1
FABS	FABS	D9 E1	设置C1 (C0, C2, C3未定义)	求绝对值：ST(0)←ABS(ST(0))	FABS
FADD	FADD m32real	D8 /0	设置C1 (C0, C2, C3未定义)	实数加法：ST(0)←ST(0)+m32real	FADD REAL4 PTR [00459AF0]
	FADD m64real	DC /0		实数加法：ST(0)←ST(0)+m64real	FADD REAL8 PTR [00459AF0]
	FADD ST(0), ST(i)	D8 C0+i		实数加法：ST(0)←ST(0)+ST(i)	FADD ST(0), ST(1)
	FADD ST(i), ST(0)	DC C0+i		实数加法：ST(i)←ST(i)+ST(0)	FADD ST(1), ST(0)
FADDP	FADDP ST(i), ST(0)	DE C0+i	设置C1 (C0, C2, C3未定义)	先进行实数加法：ST(i)←ST(i)+ST(0)，然后进行一次出栈操作	FADDP ST(1), ST(0)
FADDP	FADDP	DE C1	设置C1 (C0, C2, C3未定义)	先进行实数加法：ST(0)←ST(0)+ST(1)，然后进行一次出栈操作	FADDP
FIADD	FIADD m32int	DA /0	设置C1 (C0, C2, C3未定义)	加整数：ST(0)←ST(0)+m32int	FIADD DWORD PTR [00812CD0]
FIADD	FIADD m16int	DE /0	设置C1 (C0, C2, C3未定义)	加整数：ST(0)←ST(0)+m16int	FIADD WORD PTR [00812CD0]
FBLD	FBLD m80bcd	DF /4	设置C1 (C0, C2, C3未定义)	将BCD数装入ST(0)，然后压栈push ST(0)
FBSTP	FBSTP m80bcd	DF /6	设置C1 (C0, C2, C3未定义)	将ST(0)以BCD数保存在m80bcd，然后出栈pop ST(0)
FCHS	FCHS	D9 E0	设置C1 (C0, C2, C3未定义)	改变ST(0)的符号位，即求负数	FCHS
FCLEX	FCLEX	9B DB E2	PE, UE, OE, ZE, DE, IE, ES, SF, B 清0，设置C0 (C1, C2, C3未定义)	清除浮点异常标志(检查非屏蔽浮点异常)	FCLEX
FNCLEX	FNCLEX	DB E2	PE, UE, OE, ZE, DE, IE, ES, SF, B 清0，设置C0 (C1, C2, C3未定义)	清除浮点异常标志(不检查非屏蔽浮点异常)	FNCLEX
FCMOVcc	FCMOVB ST(0), ST(i)	DA C0+i	小于(CF=1)，设置C1 (C0, C2, C3未定义)	条件浮点传送指令	FCMOVB ST(0), ST(1)
	FCMOVE ST(0), ST(i)	DA C8+i	等于(ZF=1)，设置C1 (C0, C2, C3未定义)		FCMOVE ST(0), ST(1)
	FCMOVBE ST(0), ST(i)	DA D0+i	小于等于(CF=1 or ZF=1)，设置C1 (C0, C2, C3未定义)		FCMOVBE ST(0), ST(1)
	FCMOVU ST(0), ST(i)	DA D8+i	unordered(PF=1)，设置C1 (C0, C2, C3未定义)		FCMOVU ST(0), ST(1)
	FCMOVNB ST(0), ST(i)	DB C0+i	不小于(CF=0)，设置C1 (C0, C2, C3未定义)		FCMOVNB ST(0), ST(1)
	FCMOVNE ST(0), ST(i)	DB C8+i	不等于(ZF=0)，设置C1 (C0, C2, C3未定义)		FCMOVNE ST(0), ST(1)
	FCMOVNBE ST(0), ST(i)	DB D0+i	不小于等于(CF=0 and ZF=0)，设置C1 (C0, C2, C3未定义)		FCMOVNBE ST(0), ST(1)
	FCMOVNU ST(0), ST(i)	DB D8+i	not unordered(PF=1)，设置C1 (C0, C2, C3未定义)		FCMOVNBE ST(0), ST(1)
FCOM	FCOM m32real	D8 /2	设置C1，C0, C2, C3	实数比较：ST(0)-m32real，设置标志位	FCOM REAL4 PTR [00812CD0]
	FCOM m64real	DC /2		实数比较：ST(0)-m64real，设置标志位	FCOM REAL8 PTR [00812CD0]
	FCOM ST(i)	D8 D0+i		实数比较：ST(0)-ST(i)，设置标志位	FCOM ST(2)
	FCOM	D8 D1		实数比较：ST(0)-ST(1)，设置标志位	FCOM
FCOMP	FCOMP m32real	D8 /3	设置C1，C0, C2, C3	实数比较：ST(0)-m32real，设置标志位，执行一次出栈操作	FCOMP REAL4 PTR [00812CD0]
	FCOMP m64real	DC /3		实数比较：ST(0)-m64real，设置标志位，执行一次出栈操作	FCOMP REAL8 PTR [00812CD0]
	FCOMP ST(i)	D8 D8+i		实数比较：ST(0)-ST(i)，设置标志位，执行一次出栈操作	FCOMP ST(2)
	FCOMP	D8 D9		实数比较：ST(0)-ST(1)，设置标志位，执行一次出栈操作	FCOMP
FCOMI	FCOMI ST, ST(i)	DB F0+i	设置ZF，PF，CF，C1	实数比较：ST(0)-ST(i)，设置标志位	FCOMI ST, ST(1)
FCOMIP	FCOMIP ST, ST(i)	DF F0+i	设置ZF，PF，CF，C1	实数比较：ST(0)-ST(i)，设置标志位，执行一次出栈操作	FCOMIP ST, ST(1)
FUCOMI	FUCOMI ST, ST(i)	DB E8+i	设置ZF，PF，CF，C1	实数比较：ST(0)-ST(i)，检查ordered值，设置标志位	FCOMIP ST, ST(1)
FUCOMIP	FUCOMIP ST, ST(i)	DF E8+i	设置ZF，PF，CF，C1	实数比较：ST(0)-ST(i)，检查ordered值，设置标志位，执行一次出栈操作	FUCOMIP ST, ST(1)
FCOS	FCOS	D9 FF	设置C1，C2	余弦函数COS，ST(0)←cosine(ST(0))	FCOS
FDECSTP	FDECSTP	D9 F6	设置C1 (C0, C2, C3未定义)	将FPU的栈顶指针值减小1	FDECSTP
FDIV	FDIV m32real	D8 /6	设置C1 (C0, C2, C3未定义)	实数除法：ST(0)←ST(0)/m32real	FDIV REAL4 PTR [00459AF0]
	FDIV m64real	DC /6		实数除法：ST(0)←ST(0)/m64real	FDIV REAL8 PTR [00459AF0]
	FDIV ST(0), ST(i)	D8 F0+i		实数除法：ST(0)←ST(0)/ST(i)	FDIV ST(0), ST(1)
	FDIV ST(i), ST(0)	DC F8+i		实数除法：ST(i)←ST(i)/ST(0)	FDIV ST(1), ST(0)
FDIVP	FDIVP ST(i), ST(0)	DE F8+i	设置C1 (C0, C2, C3未定义)	实数除法：ST(i)←ST(i)/ST(0)，执行一次出栈操作	FDIVP ST(1), ST(0)
FDIVP	FDIVP	DE F9	设置C1 (C0, C2, C3未定义)	实数除法：ST(1)←ST(1)/ST(0)，执行一次出栈操作	FDIVP
FIDIV	FIDIV m32int	DA /6	设置C1 (C0, C2, C3未定义)	除以整数：ST(0)←ST(0)/m32int	FIDIV DWORD PTR [00459AF0]
FIDIV	FIDIV m16int	DE /6	设置C1 (C0, C2, C3未定义)	除以整数：ST(0)←ST(0)/m16int	FIDIV WORD PTR [00459AF0]
FDIVR	FDIVR m32real	D8 /7	设置C1 (C0, C2, C3未定义)	实数除法：ST(0)←m32real/ST(0)	FDIVR REAL4 PTR [00459AF0]
	FDIVR m64real	DC /7		实数除法：ST(0)←m64real/ST(0)	FDIVR REAL8 PTR [00459AF0]
	FDIVR ST(0), ST(i)	D8 F8+i		实数除法：ST(0)←ST(i)/ST(0)	FDIVR ST(0), ST(1)
	FDIVR ST(i), ST(0)	DC F0+i		实数除法：ST(i)←ST(0)/ST(i)	FDIVR ST(1), ST(0)
FDIVRP	FDIVRP ST(i), ST(0)	DE F0+i	设置C1 (C0, C2, C3未定义)	实数除法：ST(i)←ST(0)/ST(i)，执行一次出栈操作	FDIVRP ST(1), ST(0)
FDIVRP	FDIVRP	DE F1	设置C1 (C0, C2, C3未定义)	实数除法：ST(1)←ST(0)/ST(1)，执行一次出栈操作	FDIVRP
FIDIVR	FIDIVR m32int	DA /7	设置C1 (C0, C2, C3未定义)	被整数除：ST(0)←m32int/ST(0)	FIDIVR DWORD PTR [00459AF0]
FIDIVR	FIDIVR m16int	DE /7	设置C1 (C0, C2, C3未定义)	被整数除：ST(0)←m16int/ST(0)	FIDIVR WORD PTR [00459AF0]
FFREE	FFREE ST(i)	DD C0+i	(C0, C1，C2, C3未定义)	将与ST(i)相对应的标志位设置为空，即TAG(i)←11B	FFREE ST(1)
FICOM	FICOM m16int	DE /2	设置 C1，C0, C2, C3	和整数比较：ST(0)- m16int，设置标志	FICOM WORD PTR [00459AF0]
FICOM	FICOM m32int	DA /2	设置 C1，C0, C2, C3	和整数比较：ST(0)- m32int，设置标志	FICOM DWORD PTR [00459AF0]
FICOMP	FICOMP m16int	DE /3	设置C1，C0, C2, C3	和整数比较：ST(0)- m16int，设置标志，执行一次出栈操作	FICOMP WORD PTR [00459AF0]
FICOMP	FICOMP m32int	DA /3	设置C1，C0, C2, C3	和整数比较：ST(0)- m32int，设置标志，执行一次出栈操作	FICOMP DWORD PTR [00459AF0]
FILD	FILD m16int	DF /0	设置C1 (C0, C2, C3未定义)	将16位整数压栈，即装入ST(0)	FILD WORD PTR [00459AF0]
	FILD m32int	DB /0		将32位整数压栈，即装入ST(0)	FILD DWORD PTR [00459AF0]
	FILD m64int	DF /5		将64位整数压栈，即装入ST(0)
FINCSTP	FINCSTP	D9 F7	设置C1 (C0, C2, C3未定义)	将FPU的栈顶指针值增大1	FINCSTP
FINIT	FINIT	9B DB E3	设置C1 (C0, C2, C3未定义)	初始化FPU，检查非屏蔽浮点异常	FINIT
FNINIT	FNINIT	DB E3	设置C1 (C0, C2, C3未定义)	初始化FPU，不检查非屏蔽浮点异常	FNINIT
FIST	FIST m16int	DF /2	设置C1 (C0, C2, C3未定义)	将ST(0)以16位整数保存到m16int	FIST WORD PTR [00459AF0]
FIST	FIST m32int	DB /2	设置C1 (C0, C2, C3未定义)	将ST(0)以32位整数保存到m32int	FIST DWORD PTR [00459AF0]
FISTP	FISTP m16int	DF /3	设置C1 (C0, C2, C3未定义)	将ST(0)以16位整数保存到m16int，执行一次出栈操作	FISTP WORD PTR [00459AF0]
	FISTP m32int	DB /3		将ST(0)以32位整数保存到m32int，执行一次出栈操作	FISTP DWORD PTR [00459AF0]
	FISTP m64int	DF /7		将ST(0)以64位整数保存到m64int，执行一次出栈操作
FLD	FLD m32real	D9 /0	设置C1 (C0, C2, C3未定义)	将32位实数压栈，即装入ST(0)	FLD REAL4 PTR [00459AF0]
	FLD m64real	DD /0		将64位实数压栈，即装入ST(0)	FLD REAL8 PTR [00459AF0]
	FLD m80real	DB /5		将80位实数压栈，即装入ST(0)
	FLD ST(i)	D9 C0+i		将ST(i)压栈，即装入ST(0)	FLD ST(7)
FLD1	FLD1	D9 E8	设置C1 (C0, C2, C3未定义)	将+1.0压栈，即装入ST(0)	FLD1
FLDL2T	FLDL2T	D9 E9	设置C1 (C0, C2, C3未定义)	将log2(10)压栈，即装入ST(0)	FLDL2T
FLDL2E	FLDL2E	D9 EA	设置C1 (C0, C2, C3未定义)	将log2(e)压栈，即装入ST(0)	FLDL2E
FLDPI	FLDPI	D9 EB	设置C1 (C0, C2, C3未定义)	将pi压栈，即装入ST(0)	FLDPI
FLDLG2	FLDLG2	D9 EC	设置C1 (C0, C2, C3未定义)	将log10(2)压栈，即装入ST(0)	FLDLG2
FLDLN2	FLDLN2	D9 ED	设置C1 (C0, C2, C3未定义)	将loge(2)压栈，即装入ST(0)	FLDLN2
FLDZ	FLDZ	D9 EE	设置C1 (C0, C2, C3未定义)	将+0.0压栈，即装入ST(0)	FLDZ
FLDCW	FLDCW m2byte	D9 /5	C1, C0, C2, C3 未定义	从m2byte装入FPU控制字	FLDCW BYTE PTR [00459AF0]
FLDENV	FLDENV m14/28byte	D9 /4	C1, C0, C2, C3 未定义	从m14/28byte装入FPU环境	FLDENV BYTE PTR [00459AF0]
FMUL	FMUL m32real	D8 /1	设置C1 (C0, C2, C3未定义)	实数乘法：ST(0)←ST(0)*m32real	FMUL REAL4 PTR [00459AF0]
	FMUL m64real	DC /1		实数乘法：ST(0)←ST(0)*m64real	FMUL REAL8 PTR [00459AF0]
	FMUL ST(0), ST(i)	D8 C8+i		实数乘法：ST(0)←ST(0)*ST(i)	FMUL ST(0), ST(1)
	FMUL ST(i), ST(0)	DC C8+i		实数乘法：ST(i)←ST(i)*ST(0)	FMUL ST(1), ST(0)
FMULP	FMULP ST(i), ST(0)	DE C8+i	设置C1 (C0, C2, C3未定义)	实数乘法：ST(i)←ST(i)*ST(0)，执行一次出栈操作	FMULP ST(1), ST(0)
FMULP	FMULP	DE C9	设置C1 (C0, C2, C3未定义)	实数乘法：ST(1)←ST(1)*ST(0)，执行一次出栈操作	FMULP
FIMUL	FIMUL m32int	DA /1	设置C1 (C0, C2, C3未定义)	乘以整数：ST(0)←m32int*ST(0)	FIMUL DWORD PTR [00459AF0]
FIMUL	FIMUL m16int	DE /1	设置C1 (C0, C2, C3未定义)	乘以整数：ST(0)←m16int*ST(0)	FIMUL WORD PTR [00459AF0]
FNOP	FNOP	D9 D0	C1, C0, C2, C3 未定义	空操作(等同于NOP)	FNOP
FPATAN	FPATAN	D9 F3	设置C1 (C0, C2, C3未定义)	反正切函数arctan，ST(1)←arctan(ST(1)/ST(0))，执行一次出栈操作	FPATAN
FPREM	FPREM	D9 F8	设置C1，C0, C2, C3	取余数，ST(0)←ST(0) MOD ST(1)	FPREM
FPREM1	FPREM1	D9 F5	设置C1，C0, C2, C3	取余数(使用IEEE标准)，ST(0)←ST(0) MOD ST(1)	FPREM1
FATAN	FATAN	D9 F2	设置C1，C2 (C0, C3未定义)	正切函数Tan，ST(0)←tangent(ST(0))，执行一次压栈1.0的操作	FATAN
FRNDINT	FRNDINT	D9 FC	设置C1 (C0，C2，C3未定义)	取整(四舍五入，当小数部分刚好等于0.5时：如果整数部分为偶数，则“舍”；如果整数部分为奇数，则“入”)，ST(0)←Round(ST(0))	FRNDINT
FRSTOR	FRSTOR m94/108byte	DD /4	设置C0，C1，C2，C3	从m94/108byte装入FPU状态	FRSTOR BYTE PTR [00459AF0]
FSAVE	FSAVE m94/108byte	9B DD /6	设置C0，C1，C2，C3	将FPU状态保存在m94/108byte中，检查非屏蔽浮点异常，然后初始化FPU	FSAVE BYTE PTR [00459AF0]
FNSAVE	FNSAVE m94/108byte	9B DD /6	设置C0，C1，C2，C3	将FPU状态保存在m94/108byte中，不检查非屏蔽浮点异常，然后初始化FPU	FNSAVE BYTE PTR [00459AF0]
FSCALE	FSCALE	D9 FD	设置C1 (C0，C2，C3 未定义)	ST(0)←ST(0)* 2^ST(1)	FSCALE
FSIN	FSIN	D9 FE	设置C1，C2 (C0，C3 未定义)	正弦函数Sin，ST(0)←sine(ST(0))	FSIN
FSINCOS	FSINCOS	D9 FB	设置C1，C2 (C0，C3 未定义)	SinCos函数: ST(0)←sine(ST(0))，PUSH cosine(ST(0))	FSINCOS
FSQRT	FSQRT	D9 FA	设置C1 (C0，C2, C3 未定义)	平方根函数: ST(0)←SQRT(ST(0))	FSQRT
FST	FST m32real	D9 /2	设置C1 (C0, C2, C3未定义)	将ST(0)复制到m32real	FST REAL4 PTR [00459AF0]
	FST m64real	DD /2		将ST(0)复制到m64real	FST REAL8 PTR [00459AF0]
	FST ST(i)	DD D0+i		将ST(0)复制到ST(i)	FST ST(3)
FSTP	FSTP m32real	D9 /3	设置C1 (C0, C2, C3未定义)	将ST(0)复制到m32real，执行一次出栈操作	FSTP REAL4 PTR [00459AF0]
	FSTP m64real	DD /3		将ST(0)复制到m64real，执行一次出栈操作	FSTP REAL8 PTR [00459AF0]
	FSTP m80real	DB /7		将ST(0)复制到m80real，执行一次出栈操作
	FSTP ST(i)	DD D8+i		将ST(0)复制到ST(i)，执行一次出栈操作	FSTP ST(3)
FSTCW	FSTCW m2byte	9B D9 /7	C0，C1，C2，C3 未定义	将FPU控制字保存到m2byte，检查非屏蔽浮点异常	FSTCW BYTE PTR [00459AF0]
FNSTCW	FNSTCW m2byte	9B D9 /7	C0，C1，C2，C3 未定义	将FPU控制字保存到m2byte，不检查非屏蔽浮点异常	FNSTCW BYTE PTR [00459AF0]
FSTENV	FSTENV m14/28byte	9B D9 /6	C0，C1，C2，C3 未定义	将FPU环境保存到m14/28byte，检查非屏蔽浮点异常，然后屏蔽所有浮点异常	FSTENV BYTE PTR [00459AF0]
FNSTENV	FNSTENV m14/28byte	D9 /6	C0，C1，C2，C3 未定义	将FPU环境字保存到m14/28byte，不检查非屏蔽浮点异常，然后屏蔽所有浮点异常	FNSTENV BYTE PTR [00459AF0]
FSTSW	FSTSW m2byte	9B DD /7	C0，C1，C2，C3 未定义	将FPU状态字保存到m2byte，检查非屏蔽浮点异常	FSTSW BYTE PTR [00459AF0]
FSTSW	FSTSW AX	9B DF E0	C0，C1，C2，C3 未定义	将FPU状态字保存到AX，检查非屏蔽浮点异常	FSTSW AX
FNSTSW	FNSTSW m2byte	DD /7	C0，C1，C2，C3 未定义	将FPU状态字保存到m2byte，不检查非屏蔽浮点异常	FNSTSW BYTE PTR [00459AF0]
FNSTSW	FNSTSW AX	DF E0	C0，C1，C2，C3 未定义	将FPU状态字保存到AX，不检查非屏蔽浮点异常	FNSTSW AX
FSUB	FSUB m32real	D8 /4	设置C1 (C0, C2, C3未定义)	实数减法：ST(0)←ST(0)-m32real	FSUB REAL4 PTR [00459AF0]
	FSUB m64real	DC /4		实数减法：ST(0)←ST(0)-m64real	FSUB REAL8 PTR [00459AF0]
	FSUB ST(0), ST(i)	D8 E0-i		实数减法：ST(0)←ST(0)-ST(i)	FSUB ST(0), ST(1)
	FSUB ST(i), ST(0)	DC E8-i		实数减法：ST(i)←ST(i)-ST(0)	FSUB ST(1), ST(0)
FSUBP	FSUBP ST(i), ST(0)	DE E8-i	设置C1 (C0, C2, C3未定义)	先进行实数减法：ST(i)←ST(i)-ST(0)，然后进行一次出栈操作	FSUBP ST(1), ST(0)
FSUBP	FSUBP	DE E9	设置C1 (C0, C2, C3未定义)	先进行实数减法：ST(1)←ST(1)-ST(0)，然后进行一次出栈操作	FSUBP
FISUB	FISUB m32int	DA /4	设置C1 (C0, C2, C3未定义)	减整数：ST(0)←ST(0)-m32int	FISUB DWORD PTR [00812CD0]
FISUB	FISUB m16int	DE /4	设置C1 (C0, C2, C3未定义)	减整数：ST(0)←ST(0)-m16int	FISUB WORD PTR [00812CD0]
FSUBR	FSUBR m32real	D8 /5	设置C1 (C0, C2, C3未定义)	实数减法：ST(0)←m32real-ST(0)	FSUBR REAL4 PTR [00459AF0]
	FSUBR m64real	DC /5		实数减法：ST(0)←m64real-ST(0)	FSUBR REAL8 PTR [00459AF0]
	FSUBR ST(0), ST(i)	D8 E8+i		实数减法：ST(0)←ST(i)-ST(0)	FSUBR ST(0), ST(1)
	FSUBR ST(i), ST(0)	DC E0+i		实数减法：ST(i)←ST(0)-ST(i)	FSUBR ST(1), ST(0)
FSUBRP	FSUBRP ST(i), ST(0)	DE E0+i	设置C1 (C0, C2, C3未定义)	实数减法：ST(i)←ST(0)-ST(i)，执行一次出栈操作	FSUBRP ST(1), ST(0)
FSUBRP	FSUBRP	DE E1	设置C1 (C0, C2, C3未定义)	实数减法：ST(1)←ST(0)-ST(1)，执行一次出栈操作	FSUBRP
FISUBR	FISUBR m32int	DA /5	设置C1 (C0, C2, C3未定义)	被整数减：ST(0)←m32int-ST(0)	FISUBR DWORD PTR [00459AF0]
FISUBR	FISUBR m16int	DE /5	设置C1 (C0, C2, C3未定义)	被整数减：ST(0)←m16int-ST(0)	FISUBR WORD PTR [00459AF0]
FTST	FTST	D9 E4	设置C0，C1, C2, C3	零检测，将ST(0)和0.0相比较	FTST
FUCOM	FUCOM ST(i)	DD E0+i	设置C0，C1, C2, C3	比较ST(0)和ST(i)	FUCOM ST(4)
FUCOM	FUCOM	DD E1	设置C0，C1, C2, C3	比较ST(0)和ST(1)	FUCOM
FUCOMP	FUCOMP ST(i)	DD E8+i	设置C0，C1, C2, C3	比较ST(0)和ST(i)，执行一次出栈操作	FUCOMP ST(4)
FUCOMP	FUCOMP	DD E9	设置C0，C1, C2, C3	比较ST(0)和ST(1)，执行一次出栈操作	FUCOMP
FUCOMPP	FUCOMPP	DD E8+i	设置C0，C1, C2, C3	比较ST(0)和ST(1)，执行两次出栈操作	FUCOMPP
FWAIT	FWAIT	9B	C0，C1, C2, C3 未定义	等待，检查非屏蔽浮点异常	FWAIT
FXAM	FXAM	D9 E5	设置C0，C1, C2, C3	检查ST(0)中的数值类型	FXAM
FXCH	FXCH ST(i)	D9 C8+i	设置C1 (C0, C2, C3未定义)	交换ST(0)和ST(i)的内容	FXCH ST(4)
FXCH	FXCH	D9 C9	设置C1 (C0, C2, C3未定义)	交换ST(0)和ST(1)的内容	FXCH
FXRSTOR	FXRSTOR m512byte	0F AE /1	恢复所有标志位	由m512byte恢复寄存器x87 FPU, MMX, XMM, 和MXCSR的状态	FXRSTOR BYTE PTR [00459AF0]
FXSAVE	FXSAVE m512byte	0F AE /0	不影响标志位	将寄存器x87 FPU, MMX, XMM, 和MXCSR的状态保存到m512byte	FXSAVE BYTE PTR [00459AF0]
FXTRACT	FXTRACT	D9 F4	设置C1 (C0, C2, C3未定义)	将ST(0)中的数分成exponent和significand两部分，ST(0)←Exponent(ST(0))，PUSH Significand(ST(0))	FXTRACT
FYL2X	FYL2X	D9 F1	设置C1 (C0, C2, C3未定义)	计算：ST(1)←ST(1)*log2(ST(0))，执行一次出栈操作	FYL2X
FYL2XP1	FYL2XP1	D9 F9	设置C1 (C0, C2, C3未定义)	计算：ST(1) ←ST(1)*log2(ST(0) + 1.0)，执行一次出栈操作	FYL2XP1
HLT	HLT	F4	不影响标志位	系统进入暂停状态	HLT
IDIV	IDIV r/m8	F6 /7	AF CF OF PF SF ZF 未定义	有符号除法	IDIV BL ；AX除以BL，商在AL中，余数在AH中
	IDIV r/m16	F7 /7			IDIV BX ；DX：AX除以BX，商在AX中，余数在DX中
	IDIV r/m32	F7 /7			IDIV EBX；EDX：EAX除以BX，商在EAX中，余数在EDX中
IMUL	IMUL r/m8	F6 /5	设置CF OF (SF ZF AF PF未定义)	有符号乘法：AX←AL*r/m8	IMUL CL
	IMUL r/m16	F7 /5		有符号乘法：DX:AX←AX*r/m16	IMUL CX
	IMUL r/m32	F7 /5		有符号乘法：EDX:EAX←EAX*r/m32	IMUL ECX
	IMUL r16, r/m16	0F AF /r		有符号乘法：r16←r16*r/m16	IMUL AX, BX
	IMUL r32, r/m32	0F AF /r		有符号乘法：r32←r32*r/m32	IMUL EAX, EBX
	IMUL r16,r/m16,imm8	6B /r ib		有符号乘法：r16←r/m16*imm8	IMUL AX, BX, 39
	IMUL r32,r/m32,imm8	6B /r ib		有符号乘法：r32←r/m32*imm8	IMUL EAX, EBX, 39
	IMUL r16, imm8	6B /r ib		有符号乘法：r16←r16*imm8	IMUL AX, 37
	IMUL r32, imm8	6B /r ib		有符号乘法：r32←r32*imm8	IMUL EAX, 37
	IMUL r16,r/m16,imm16	69 /r iw		有符号乘法：r16←r/m16*imm16	IMUL AX, BX, 387E
	IMUL r32,r/m32,imm32	69 /r id		有符号乘法：r32←r/m32*imm32	IMUL EAX, EBX, 006387EA
	IMUL r16, imm16	69 /r iw		有符号乘法：r16←r16*imm16	IMUL AX, 387E
	IMUL r32, imm32	69 /r id		有符号乘法：r32←r32*imm32	IMUL EAX, 006387EA
IN	IN AL,imm8	E4 ib	不影响标志位	从imm8指定的端口读字节(BYTE)到AL	IN AL,E0
	IN AX,imm8	E5 ib		从imm8指定的端口读字节(BYTE)到AX	IN AX,E0
	IN EAX,imm8	E5 ib		从imm8指定的端口读字节(BYTE)到EAX	IN EAX,E0
	IN AL,DX	EC		从DX指定的端口读字节(BYTE)到AL	IN AL,DX
	IN AX,DX	ED		从DX指定的端口读字(WORD)到AX	IN AX,DX
	IN EAX,DX	ED		从DX指定的端口读双字(DWORD)到EAX	IN EAX,DX
INC	INC r/m8	FE /0	设置 OF SF ZF AF PF	目标加1	INC BYTE PTR [00459AF0]
	INC r/m16	FF /0			INC WORD PTR [00459AF0]
	INC r/m32	FF /0			INC DWORD PTR [00459AF0]
	INC r16	40+rw			INC DX
	INC r32	40+rd			INC EDX
INS	INS m8, DX	6C	不影响标志位	从DX指定的端口读字节(BYTE)到ES:(E)DI
	INS m16, DX	6D		从DX指定的端口读字(WORD)到ES:(E)DI
	INS m32, DX	6D		从DX指定的端口读双字(DWORD)到ES:(E)DI
INSB	INSB	6C	不影响标志位	从DX指定的端口读字节(BYTE)到ES:(E)DI	INSB
INSW	INSW	6D	不影响标志位	从DX指定的端口读字(WORD)到ES:(E)DI	INSW
INSD	INSD	6D	不影响标志位	从DX指定的端口读双字(DWORD)到ES:(E)DI	INSD
INT 3	INT 3	CC	标志位被保存压栈	调试陷阱中断	INT 3
INT imm8	INT imm8	CD ib	标志位被保存压栈	中断功能调用，imm8是中断向量号	INT 21
INTO	INTO	CE	标志位被保存压栈	溢出中断，条件：OV=1，4号中断功能调用	INTO
INVD	INVD	0F 08	不影响标志位	使内部CACHES无效，初始化外部CACHES	INVD
INVLPG	INVLPG	0F 01/7	不影响标志位	使TLB项无效	INVLPG [EBX]
IRET	IRET	CF	恢复被压栈的标志位	中断返回(16位)	IRET
IRETD	IRETD	CF	恢复被压栈的标志位	中断返回(32位)	IRETD
Jcc	JA rel8	77 cb	高于(CF=0 and ZF=0)	条件转移指令
	JAE rel8	73 cb	高于等于(CF=0)
	JB rel8	72 cb	低于(CF=1)
	JBE rel8	76 cb	低于等于(CF=1 or ZF=1)
	JC rel8	72 cb	有进位(CF=1)
	JCXZ rel8	E3 cb	CX=0则跳
	JECXZ rel8	E3 cb	ECX=0则跳
	JE rel8	74 cb	等于(ZF=1)
	JG rel8	7F cb	大于(ZF=0 and SF=OF)
	JGE rel8	7D cb	大于等于(SF=OF)
	JL rel8	7C cb	小于(SF<>OF)
	JLE rel8	7E cb	小于等于(ZF=1 or SF<>OF)
	JNA rel8	76 cb	不高于(CF=1 or ZF=1)
	JNAE rel8	72 cb	不高等于(CF=1)
	JNB rel8	73 cb	不低于(CF=0)
	JNBE rel8	77 cb	不低等于(CF=0 and ZF=0)
	JNC rel8	73 cb	无进位(CF=0)
	JNE rel8	75 cb	不等于(ZF=0)
	JNG rel8	7E cb	不大于(ZF=1 or SF<>OF)
	JNGE rel8	7C cb	不大等于(SF<>OF)
	JNL rel8	7D cb	不小于(SF=OF)
	JNLE rel8	7F cb	不小等于(ZF=0 and SF=OF)
	JNO rel8	71 cb	无溢出(OF=0)
	JNP rel8	7B cb	非偶数(PF=0)
	JNS rel8	79 cb	非负数(SF=0)
	JNZ rel8	75 cb	非零(ZF=0)
	JO rel8	70 cb	溢出(OF=1)
	JP rel8	7A cb	偶数(PF=1)
	JPE rel8	7A cb	偶数(PF=1)
	JPO rel8	7B cb	奇数(PF=0)
	JS rel8	78 cb	负数(SF=1)
	JZ rel8	74 cb	为零(ZF=1)
	JA rel16/32	0F 87 cw/cd	高于(CF=0 and ZF=0)
	JAE rel16/32	0F 83 cw/cd	高于等于(CF=0)
	JB rel16/32	0F 82 cw/cd	低于(CF=1)
	JBE rel16/32	0F 86 cw/cd	低于等于(CF=1 or ZF=1)
	JC rel16/32	0F 82 cw/cd	有进位(CF=1)
	JE rel16/32	0F 84 cw/cd	等于(ZF=1)
	JZ rel16/32	0F 84 cw/cd	为零(ZF=1)
	JG rel16/32	0F 8F cw/cd	大于(ZF=0 and SF=OF)
JMP	JMP rel8	EB cb	不影响标志位	无条件转移指令
	JMP rel16	E9 cw
	JMP rel32	E9 cd
	JMP r/m16	FF /4
	JMP r/m32	FF /4
	JMP ptr16:16	EA cd
	JMP ptr16:32	EA cp
	JMP m16:16	FF /5
	JMP m16:32	FF /5
LAHF	LAHF	9F	不影响标志位	将标志寄存器的低字节送入AH，格式为：AH=(SF:ZF:0:AF:0:PF:1:CF)	LAHF
LAR	LAR r16,r/m16	0F 02 /r	设置ZF	将源操作数指定的选择子访问权送目标寄存器	LAR AX，BX
LAR	LAR r32,r/m32	0F 02 /r	设置ZF	将源操作数指定的选择子访问权送目标寄存器	LAR EAX，EBX
LDS	LDS r16,m16:16	C5 /r	不影响标志位	从内存位置m16:16装入地址值DS:r16
LDS	LDS r32,m16:32	C5 /r	不影响标志位	从内存位置m16:32装入地址值DS:r32
LSS	LSS r16,m16:16	0F B2 /r	不影响标志位	从内存位置m16:16装入地址值SS:r16
LSS	LSS r32,m16:32	0F B2 /r	不影响标志位	从内存位置m16:32装入地址值SS:r32
LES	LES r16,m16:16	C4 /r	不影响标志位	从内存位置m16:16装入地址值ES:r16
LES	LES r32,m16:32	C4 /r	不影响标志位	从内存位置m16:32装入地址值ES:r32
LFS	LFS r16,m16:16	0F B4 /r	不影响标志位	从内存位置m16:16装入地址值FS:r16
LFS	LFS r32,m16:32	0F B4 /r	不影响标志位	从内存位置m16:32装入地址值FS:r32
LGS	LGS r16,m16:16	0F B5 /r	不影响标志位	从内存位置m16:16装入地址值GS:r16
LGS	LGS r32,m16:32	0F B5 /r	不影响标志位	从内存位置m16:32装入地址值GS:r32
LEA	LEA r16,m	8D /r	不影响标志位	将源操作数的有效地址送r16
LEA	LEA r32,m	8D /r	不影响标志位	将源操作数的有效地址送r32
LEAVE	LEAVE	C9	不影响标志位	子过程返回释放堆栈框架	LEAVE
LGDT	LGDT m16&32	0F 01 /2	不影响标志位	将内存m16&32处的值装入全局描述符表寄存器	LGDT [EBP]
LIDT	LIDT m16&32	0F 01 /3	不影响标志位	将内存m16&32处的值装入中断描述符表寄存器	LIDT [SI]
LLDT	LLDT r/m16	0F 00 /2	不影响标志位	将r/m16处的值装入局部描述符表寄存器	LLDT BX
LMSW	LMSW r/m16	0F 01 /6	不影响标志位	将r/m16处的值装入机器状态字	LMSW [BP]
LOCK	LOCK	F0	不影响标志位	总线锁定	LOCK
LODS	LODS m8	AC	不影响标志位	将地址DS:(E)SI的值装入AL
	LODS m16	AD		将地址DS:(E)SI的值装入AX
	LODS m32	AD		将地址DS:(E)SI的值装入EAX
LODSB	LODSB	AC	不影响标志位	将地址DS:(E)SI的值装入AL	LODSB
LODSW	LODSW	AD	不影响标志位	将地址DS:(E)SI的值装入AX	LODSW
LODSD	LODSD	AD	不影响标志位	将地址DS:(E)SI的值装入EAX	LODSD
LOOP	LOOP rel8	E2 cb	不影响标志位	条件循环指令，循环条件：CX/ECX != 0
LOOPE	LOOPE rel8	E1 cb	不影响标志位	条件循环指令，循环条件：CX/ECX != 0 且 ZF=1
LOOPZ	LOOPZ rel8	E1 cb	不影响标志位	条件循环指令，循环条件：CX/ECX != 0 且 ZF=1
LOOPNE	LOOPNE rel8	E1 cb	不影响标志位	条件循环指令，循环条件：CX/ECX != 0 且 ZF=0
LOOPNZ	LOOPNZ rel8	E1 cb	不影响标志位	条件循环指令，循环条件：CX/ECX != 0 且 ZF=0
LSL	LSL r16,r/m16	0F 03 /r	设置ZF	装入选择子对应的描述符的段界限	LSL AX,BX
LSL	LSL r32,r/m32	0F 03 /r	设置ZF	装入选择子对应的描述符的段界限	LSL EAX,EBX
LTR	LTR r/m16	0F 00 /3	不影响标志位	装入任务寄存器	LTR AX
MOV	MOV r/m8,r8	88 /r	不影响标志位	传送指令	MOV [00459AF0],AL
	MOV r/m16,r16	89 /r			MOV [00459AF0],AX
	MOV r/m32,r32	89 /r			MOV [00459AF0],EAX
	MOV r8,r/m8	8A /r			MOV AL,[00459AF0]
	MOV r16,r/m16	8B /r			MOV AX,[00459AF0]
	MOV r32,r/m32	8B /r			MOV EAX,[00459AF0]
	MOV r/m16,Sreg	8C /r			MOV AX,ES
	MOV Sreg,r/m16	8E /r			MOV ES,AX
	MOV AL,moffs8	A0			MOV AL,ES:[459A]
	MOV AX,moffs16	A1			MOV AX,ES:[459A]
	MOV EAX,moffs32	A1			MOV EAX,ES:[00459AF0]
	MOV moffs8,AL	A2			MOV ES:[459A],AL
	MOV moffs16,AX	A3			MOV ES:[459A],AX
	MOV moffs32,EAX	A3			MOV ES:[00459AF0],EAX
	MOV r8,imm8	B0+rb			MOV AL,F0
	MOV r16,imm16	B8+rw			MOV AX,9AF0
	MOV r32,imm32	B8+rd			MOV EAX,00459AF0
	MOV r/m8,imm8	C6 /0			MOV BYTE PTR [00459AF0],F0
	MOV r/m16,imm16	C7 /0			MOV WORD PTR [00459AF0],9AF0
	MOV r/m32,imm32	C7 /0			MOV DWORD PTR [00459AF0],00459AF0
MOV	MOV CR0,r32	0F 22 /r	不影响标志位	控制寄存器传送指令	MOV CR0,EAX
	MOV CR2,r32	0F 22 /r			MOV CR2,EAX
	MOV CR3,r32	0F 22 /r			MOV CR3,EAX
	MOV CR4,r32	0F 22 /r			MOV CR4,EAX
	MOV r32，CR0	0F 20 /r			MOV EAX，CR0
	MOV r32，CR2	0F 20 /r			MOV EAX，CR2
	MOV r32，CR3	0F 20 /r			MOV EAX，CR3
	MOV r32，CR4	0F 20 /r			MOV EAX，CR4
MOV	MOV r32, DR0-DR7	0F 21 /r	不影响标志位	调试寄存器传送指令	MOV EAX，DR0
MOV	MOV DR0-DR7,r32	0F 23 /r	不影响标志位	调试寄存器传送指令	MOV DR0，EAX
MOVD	MOVD mm, r/m32	0F 6E /r	不影响标志位	双字传送指令
	MOVD r/m32, mm	0F 7E /r
	MOVD xmm, r/m32	66 0F 6E /r
	MOVD r/m32, xmm	66 0F 7E /r
MOVQ	MOVQ mm, r/m64	0F 6F /r	不影响标志位	八字节传送指令
	MOVQ mm/m64, mm	0F 7F /r
	MOVQ xmm1, xmm2/m64	F3 0F 7E
	MOVQ xmm2/m64, xmm1	66 0F D6
MOVS	MOVS m8, m8	A4	不影响标志位	字符串传送，每次传送1个字节	MOVS STRING1, STRING2 ；源串DS:(E)SI，目的串：ES:(E)DI
	MOVS m16, m16	A5		字符串传送，每次传送1个字	MOVS STRING1, STRING2 ；源串DS:(E)SI，目的串：ES:(E)DI
	MOVS m32, m32	A5		字符串传送，每次传送1个双字	MOVS STRING1, STRING2 ；源串DS:(E)SI，目的串：ES:(E)DI (386+)
	MOVSB	A4		字符串传送，每次传送1个字节	MOVSB ；源串DS:(E)SI，目的串：ES:(E)DI
	MOVSW	A5		字符串传送，每次传送1个字	MOVSW ；源串DS:(E)SI，目的串：ES:(E)DI
	MOVSD	A5		字符串传送，每次传送1个双字	MOVSD ；源串DS:(E)SI，目的串：ES:(E)DI (386+)
MOVSX	MOVSX r16,r/m8	0F BE /r	不影响标志位	带符号扩展传送指令	MOVSX AX, BL
	MOVSX r32,r/m8	0F BE /r			MOVSX EAX，BL
	MOVSX r32,r/m16	0F BF /r			MOVSX EAX，BX
MOVZX	MOVZX r16,r/m8	0F B6 /r	不影响标志位	零扩展传送指令	MOVZX AX, BL
	MOVZX r32,r/m8	0F B6 /r			MOVZX EAX，BL
	MOVZX r32,r/m16	0F B7 /r			MOVZX EAX，BX
MUL	MUL r/m8	F6 /4	设置CF OF (SF ZF AF PF未定义)	无符号乘法：AX←AL*r/m8	MUL CL
	MUL r/m16	F7 /4		无符号乘法：DX:AX←AX*r/m16	MUL CX
	MUL r/m32	F7 /4		无符号乘法：EDX:EAX←EAX*r/m32	MUL ECX
NEG	NEG r/m8	F6 /3	设置CF OF SF ZF AF PF	取负：r/m8=-r/m8	NEG CL
	NEG r/m16	F7 /3		取负：r/m16=-r/m16	NEG CX
	NEG r/m32	F7 /3		取负：r/m32=-r/m32	NEG ECX
NOP	NOP	90	不影响标志位	空操作	NOP
NOT	NOT r/m8	F6 /2	设置CF OF SF ZF AF PF	按位取反：r/m8=NOT r/m8	NOT CL
	NOT r/m16	F7 /2		按位取反：r/m16=NOT r/m16	NOT CX
	NOT r/m32	F7 /2		按位取反：r/m32=NOT r/m32	NOT ECX
OR	OR AL, imm8	0C ib	设置 CF OF PF SF ZF	逻辑或	OR AL, 1F
	OR AX, imm16	0D iw			OR AX, 4F80
	OR EAX, imm32	0D id			OR EAX, 00004F80
	OR r/m8, imm8	80 /1 ib			OR BYTE PTR [006387EA], 39
	OR r/m16,imm16	81 /1 iw			OR WORD PTR [006387EA], 1039
	OR r/m32,imm32	81 /1 id			OR DWORD PTR [006387EA], 00001039
	OR r/m16,imm8	83 /1 ib			OR WORD PTR [006387EA], 39
	OR r/m32,imm8	83 /1 ib			OR DWORD PTR [006387EA], 39
	OR r/m8,r8	08 /r			OR [006387EA], AL
	OR r/m16,r16	09 /r			OR [006387EA], AX
	OR r/m32,r32	09 /r			OR [006387EA], EAX
	OR r8,r/m8	0A /r			OR AL, [006387EA]
	OR r16,r/m16	0B /r			OR AX, [006387EA]
	OR r32,r/m32	0B /r			OR EAX, [006387EA]
OUT	OUT imm8,AL	E6 ib	不影响标志位	将AL输出到imm8指定的端口	OUT E0,AL
	OUT imm8,AX	E7 ib		将AX输出到imm8指定的端口	OUT E0,AX
	OUT imm8,EAX	E7 ib		将EAX输出到imm8指定的端口	OUT E0,EAX
	OUT AL,DX	EE		将AL输出到DX指定的端口	OUT DX,AL
	OUT AX,DX	EF		将AX输出到DX指定的端口	OUT DX,AX
	OUT EAX,DX	EF		将EAX输出到DX指定的端口	OUT DX,EAX
OUTS	OUTS DX,m8	6E	不影响标志位	将DS:(E)SI处的字节输出到DX指定的端口
	OUTS DX,m16	6F		将DS:(E)SI处的字输出到DX指定的端口
	OUTS DX,m32	6F		将DS:(E)SI处的双字输出到DX指定的端口
OUTSB	OUTSB	6E	不影响标志位	将DS:(E)SI处的字节输出到DX指定的端口	OUTSB
OUTSW	OUTSW	6F	不影响标志位	将DS:(E)SI处的字输出到DX指定的端口	OUTSW
OUTSD	OUTSD	6F	不影响标志位	将DS:(E)SI处的双字输出到DX指定的端口	OUTSD
PACKSSWB	PACKSSWB mm1, mm2/m64	0F 63 /r	不影响标志位	紧缩带符号字到字节，溢出取饱和值
PACKSSWB	PACKSSWB xmm1,xmm2/m128	66 0F 63 /r	不影响标志位	紧缩带符号字到字节，溢出取饱和值	PACKSSWB XMM0，XMM1
PACKSSDW	PACKSSDW mm1, mm2/m64	0F 6B /r	不影响标志位	紧缩带符号双字到字，溢出取饱和值
PACKSSDW	PACKSSDW xmm1,xmm2/m128	66 0F 6B /r	不影响标志位	紧缩带符号双字到字，溢出取饱和值	PACKSSDW XMM0，XMM1
PACKUSWB	PACKUSWB mm1, mm2/m64	0F 67 /r	不影响标志位	紧缩无符号字到字节，溢出取饱和值
PACKUSWB	PACKUSWB xmm1,xmm2/m128	66 0F 67 /r	不影响标志位	紧缩无符号字到字节，溢出取饱和值	PACKUSWB XMM0，XMM1
PADDB	PADDB mm, mm/m64	0F FC /r	不影响标志位	紧缩字节相加，溢出则回绕
PADDB	PADDB xmm1,xmm2/m128	66 0F FC /r	不影响标志位	紧缩字节相加，溢出则回绕	PADDB XMM6，XMM7
PADDW	PADDW mm, mm/m64	0F FD /r	不影响标志位	紧缩字相加，溢出则回绕
PADDW	PADDW xmm1,xmm2/m128	66 0F FD /r	不影响标志位	紧缩字相加，溢出则回绕	PADDW XMM6，XMM7
PADDD	PADDD mm, mm/m64	0F FE /r	不影响标志位	紧缩双字相加，溢出则回绕
PADDD	PADDD xmm1,xmm2/m128	66 0F FE /r	不影响标志位	紧缩双字相加，溢出则回绕	PADDD XMM6，XMM7
PADDQ	PADDQ mm1, mm2/m64	0F D4 /r	不影响标志位	紧缩四字相加，溢出则回绕
PADDQ	PADDQ xmm1,xmm2/m128	66 0F D4 /r	不影响标志位	紧缩四字相加，溢出则回绕	PADDQ XMM6，XMM7
PADDSB	PADDSB mm, mm/m64	0F EC /r	不影响标志位	带符号紧缩字节相加，溢出取饱和值
PADDSB	PADDSB xmm1,xmm2/m128	66 0F EC /r	不影响标志位	带符号紧缩字节相加，溢出取饱和值	PADDSB XMM6，XMM7
PADDSW	PADDSW mm, mm/m64	0F ED /r	不影响标志位	带符号紧缩字相加，溢出取饱和值
PADDSW	PADDSW xmm1,xmm2/m128	66 0F ED /r	不影响标志位	带符号紧缩字相加，溢出取饱和值	PADDSW XMM6，XMM7
PADDUSB	PADDUSB mm, mm/m64	0F DC /r	不影响标志位	无符号紧缩字节相加，溢出取饱和值
PADDUSB	PADDUSB xmm1,xmm2/m128	66 0F DC /r	不影响标志位	无符号紧缩字节相加，溢出取饱和值	PADDUSB XMM0，XMM1
PADDUSW	PADDUSW mm, mm/m64	0F DD /r	不影响标志位	无符号紧缩字相加，溢出取饱和值
PADDUSW	PADDUSW xmm1,xmm2/m128	66 0F DD /r	不影响标志位	无符号紧缩字相加，溢出取饱和值	PADDUSW XMM1，XMM2
PAND	PAND mm, mm/m64	0F DB /r	不影响标志位	逻辑与操作
PAND	PAND xmm1,xmm2/m128	66 0F DB /r	不影响标志位	逻辑与操作	PAND XMM4，XMM1
PANDN	PANDN mm, mm/m64	0F DF /r	不影响标志位	求反后与操作：DEST ←(NOT DEST) AND SRC
PANDN	PANDN xmm1,xmm2/m128	66 0F DF /r	不影响标志位	求反后与操作：DEST ←(NOT DEST) AND SRC	PANDN XMM4，XMM1
PAUSE	PAUSE	F3 90	不影响标志位	改善处理器的“spin-wait loop”性能	PAUSE
PAVGB	PAVGB mm, mm/m64	0F E0 /r	不影响标志位	取紧缩无符号字节的平均值(四舍五入)
PAVGB	PAVGB xmm1,xmm2/m128	0F E0 /r	不影响标志位	取紧缩无符号字节的平均值(四舍五入)	PAVGB XMM4，XMM1
PAVGW	PAVGW mm, mm/m64	0F E0 /r	不影响标志位	取紧缩无符号字的平均值(四舍五入)
PAVGW	PAVGW xmm1,xmm2/m128	0F E0 /r	不影响标志位	取紧缩无符号字的平均值(四舍五入)	PAVGW XMM4，XMM1
PCMPEQB	PCMPEQB mm, mm/m64	0F 74 /r	不影响标志位	紧缩字节相等比较
PCMPEQB	PCMPEQB xmm1,xmm2/m128	66 0F 74 /r	不影响标志位	紧缩字节相等比较	PCMPEQB XMM4，XMM1
PCMPEQW	PCMPEQW mm, mm/m64	0F 75 /r	不影响标志位	紧缩字相等比较
PCMPEQW	PCMPEQW xmm1,xmm2/m128	66 0F 75 /r	不影响标志位	紧缩字相等比较	PCMPEQW XMM4，XMM1
PCMPEQD	PCMPEQD mm, mm/m64	0F 76 /r	不影响标志位	紧缩双字相等比较
PCMPEQD	PCMPEQD xmm1,xmm2/m128	66 0F 76 /r	不影响标志位	紧缩双字相等比较	PCMPEQD XMM4，XMM1
PCMPGTB	PCMPGTB mm, mm/m64	0F 64 /r	不影响标志位	带符号紧缩字节大于比较
PCMPGTB	PCMPGTB xmm1,xmm2/m128	66 0F 64 /r	不影响标志位	带符号紧缩字节大于比较	PCMPGTB XMM4，XMM1
PCMPGTW	PCMPGTW mm, mm/m64	0F 65 /r	不影响标志位	带符号紧缩字大于比较
PCMPGTW	PCMPGTW xmm1,xmm2/m128	66 0F 65 /r	不影响标志位	带符号紧缩字大于比较	PCMPGTW XMM4，XMM1
PCMPGTD	PCMPGTD mm, mm/m64	0F 66 /r	不影响标志位	带符号紧缩双字大于比较
PCMPGTD	PCMPGTD xmm1,xmm2/m128	66 0F 66 /r	不影响标志位	带符号紧缩双字大于比较	PCMPGTD XMM4，XMM1
PMADDWD	PMADDWD mm, mm/m64	0F F5 /r	不影响标志位	紧缩乘和加操作
PMADDWD	PMADDWD xmm1,xmm2/m128	66 0F F5 /r	不影响标志位	紧缩乘和加操作	PMADDWD XMM4，XMM1
PMAXSW	PMAXSW mm1, mm2/m64	0F EE /r	不影响标志位	有符号字比较，返回最大值
PMAXSW	PMAXSW xmm1,xmm2/m128	66 0F EE /r	不影响标志位	有符号字比较，返回最大值	PMAXSW XMM4，XMM1
PMAXUB	PMAXUB mm1, mm2/m64	0F DE /r	不影响标志位	无符号字比较，返回最大值
PMAXUB	PMAXUB xmm1,xmm2/m128	66 0F DE /r	不影响标志位	无符号字比较，返回最大值	PMAXUB XMM4，XMM1
PMINSW	PMINSW mm1, mm2/m64	0F EA /r	不影响标志位	有符号字比较，返回最小值
PMINSW	PMINSW xmm1,xmm2/m128	66 0F EA /r	不影响标志位	有符号字比较，返回最小值	PMINSW XMM4，XMM1
PMINUB	PMINUB mm1, mm2/m64	0F DA /r	不影响标志位	无符号字比较，返回最小值
PMINUB	PMINUB xmm1,xmm2/m128	66 0F DA /r	不影响标志位	无符号字比较，返回最小值	PMINUB XMM4，XMM1
PMULHUW	PMULHUW mm1, mm2/m64	0F E4 /r	不影响标志位	紧缩无符号字相乘，存高位
PMULHUW	PMULHUW xmm1,xmm2/m128	66 0F E4 /r	不影响标志位	紧缩无符号字相乘，存高位	PMULHUW XMM4，XMM1
PMULHW	PMULHW mm1, mm2/m64	0F E5 /r	不影响标志位	紧缩有符号字相乘，存高位
PMULHW	PMULHW xmm1,xmm2/m128	66 0F E5 /r	不影响标志位	紧缩有符号字相乘，存高位	PMULHW XMM4，XMM1
PMULLW	PMULLW mm1, mm2/m64	0F D5 /r	不影响标志位	紧缩有符号字相乘，存低位
PMULLW	PMULLW xmm1,xmm2/m128	66 0F D5 /r	不影响标志位	紧缩有符号字相乘，存低位	PMULLW XMM4，XMM1
PMULUDQ	PMULUDQ mm1, mm2/m64	0F F4 /r	不影响标志位	无符号双字相乘，存四字
PMULUDQ	PMULUDQ xmm1,xmm2/m128	66 OF F4 /r	不影响标志位	无符号双字相乘，存四字	PMULUDQ XMM4，XMM1
POP	POP r/m16	8F /0	不影响标志位	16位数据出栈	POP WORD PTR [006387EA]
	POP r/m32	8F /0		32位数据出栈	POP DWORD PTR [006387EA]
	POP r16	58+rw		16位数据出栈到寄存器	POP AX
	POP r32	58+rd		32位数据出栈到寄存器	POP EAX
	POP DS	1F		数据出栈到寄存器DS	POP DS
	POP ES	07		数据出栈到寄存器ES	POP ES
	POP SS	17		数据出栈到寄存器SS	POP SS
	POP FS	0F A1		数据出栈到寄存器FS	POP FS
	POP GS	0F A9		32位数据出栈到寄存器GS	POP GS
POPA	POPA	61	不影响标志位	从堆栈中弹出全部16位通用寄存器：DI, SI, BP, BX, DX, CX, AX	POPA
POPAD	POPAD	61	不影响标志位	从堆栈中弹出全部32位通用寄存器：EDI, ESI, EBP, EBX, EDX, ECX, EAX	POPAD
POPF	POPF	9D	设置所有标志位	从堆栈中弹出16位标志寄存器	POPF
POPFD	POPFD	9D	设置所有标志位	从堆栈中弹出32位标志寄存器	POPFD
POR	POR mm, mm/m64	0F EB /r	不影响标志位	逻辑或操作
POR	POR xmm1,xmm2/m128	66 0F EB /r	不影响标志位	逻辑或操作	POR XMM4，XMM1
PSLLD	PSLLD mm, mm/m64	0F F2 /r	不影响标志位	紧缩双字逻辑左移
	PSLLD xmm1,xmm2/m128	66 0F F2 /r			PSLLD XMM4，XMM1
	PSLLD mm, imm8	0F 72 /6 ib
	PSLLD xmm1, imm8	66 0F 72 /6 ib
PSLLQ	PSLLQ mm, mm/m64	0F F3 /r	不影响标志位	紧缩四字逻辑左移
	PSLLQ xmm1,xmm2/m128	66 0F F3 /r			PSLLQ XMM4，XMM1
	PSLLQ mm, imm8	0F 73 /6 ib
	PSLLQ xmm1, imm8	66 0F 73 /6 ib
PSLLW	PSLLW mm, mm/m64	0F F1 /r	不影响标志位	紧缩字逻辑左移
	PSLLW xmm1,xmm2/m128	66 0F F1 /r			PSLLW XMM4，XMM1
	PSLLW mm, imm8	0F 71 /6 ib
	PSLLW xmm1, imm8	66 0F 71 /6 ib
PSRAD	PSRAD mm, mm/m64	0F E2 /r	不影响标志位	紧缩双字算术右移
	PSRAD xmm1,xmm2/m128	66 0F E2 /r			PSRAD XMM4，XMM1
	PSRAD mm, imm8	0F 72 /4 ib
	PSRAD xmm1, imm8	66 0F 72 /4 ib
PSRAW	PSRAW mm, mm/m64	0F E1 /r	不影响标志位	紧缩字算术右移
	PSRAW xmm1,xmm2/m128	66 0F E1 /r			PSRAW XMM4，XMM1
	PSRAW mm, imm8	0F 71 /4 ib
	PSRAW xmm1, imm8	66 0F 71 /4 ib
PSRLD	PSRLD mm, mm/m64	0F D2 /r	不影响标志位	紧缩双字逻辑右移
	PSRLD xmm1,xmm2/m128	66 0F D2 /r			PSRLD XMM4，XMM1
	PSRLD mm, imm8	0F 72 /2 ib
	PSRLD xmm1, imm8	66 0F 72 /2 ib
PSRLQ	PSRLQ mm, mm/m64	0F D3 /r	不影响标志位	紧缩四字逻辑右移
	PSRLQ xmm1,xmm2/m128	66 0F D3 /r			PSRLQ XMM4，XMM1
	PSRLQ mm, imm8	0F 73 /2 ib
	PSRLQ xmm1, imm8	66 0F 73 /2 ib
PSRLW	PSRLW mm, mm/m64	0F D1 /r	不影响标志位	紧缩字逻辑右移
	PSRLW xmm1,xmm2/m128	66 0F D1 /r			PSRLW XMM4，XMM1
	PSRLW mm, imm8	0F 71 /2 ib
	PSRLW xmm1, imm8	66 0F 71 /2 ib
PSUBB	PSUBB mm, mm/m64	0F F8 /r	不影响标志位	紧缩字节减法，溢出则回绕
PSUBB	PSUBB xmm1,xmm2/m128	66 0F F8 /r	不影响标志位	紧缩字节减法，溢出则回绕	PSUBB XMM6，XMM7
PSUBW	PSUBW mm, mm/m64	0F F9 /r	不影响标志位	紧缩字减法，溢出则回绕
PSUBW	PSUBW xmm1,xmm2/m128	66 0F F9 /r	不影响标志位	紧缩字减法，溢出则回绕	PSUBW XMM6，XMM7
PSUBD	PSUBD mm, mm/m64	0F FA /r	不影响标志位	紧缩双字减法，溢出则回绕
PSUBD	PSUBD xmm1,xmm2/m128	66 0F FA /r	不影响标志位	紧缩双字减法，溢出则回绕	PSUBD XMM6，XMM7
PSUBQ	PSUBQ mm1, mm2/m64	0F FB /r	不影响标志位	紧缩四字减法，溢出则回绕
PSUBQ	PSUBQ xmm1,xmm2/m128	66 0F FB /r	不影响标志位	紧缩四字减法，溢出则回绕	PSUBQ XMM6，XMM7
PSUBSB	PSUBSB mm, mm/m64	0F E8 /r	不影响标志位	带符号紧缩字节减法，溢出取饱和值
PSUBSB	PSUBSB xmm1,xmm2/m128	66 0F E8 /r	不影响标志位	带符号紧缩字节减法，溢出取饱和值	PSUBSB XMM6，XMM7
PSUBSW	PSUBSW mm, mm/m64	0F E9 /r	不影响标志位	带符号紧缩字减法，溢出取饱和值
PSUBSW	PSUBSW xmm1,xmm2/m128	66 0F E9 /r	不影响标志位	带符号紧缩字减法，溢出取饱和值	PSUBSW XMM6，XMM7
PSUBUSB	PSUBUSB mm, mm/m64	0F D8 /r	不影响标志位	无符号紧缩字节减法，溢出取饱和值
PSUBUSB	PSUBUSB xmm1,xmm2/m128	66 0F D8 /r	不影响标志位	无符号紧缩字节减法，溢出取饱和值	PSUBUSB XMM6，XMM7
PSUBUSW	PSUBUSW mm, mm/m64	0F D9 /r	不影响标志位	无符号紧缩字减法，溢出取饱和值
PSUBUSW	PSUBUSW xmm1,xmm2/m128	66 0F D9 /r	不影响标志位	无符号紧缩字减法，溢出取饱和值	PSUBUSW XMM6，XMM7
PUNPCKHBW	PUNPCKHBW mm, mm/m64	0F 68 /r	不影响标志位	反紧缩高位，字节到字
PUNPCKHBW	PUNPCKHBW xmm1,xmm2/m128	66 0F 68 /r	不影响标志位	反紧缩高位，字节到字	PUNPCKHBW XMM6，XMM7
PUNPCKHWD	PUNPCKHWD mm, mm/m64	0F 69 /r	不影响标志位	反紧缩高位，字到双字
PUNPCKHWD	PUNPCKHWD xmm1,xmm2/m128	66 0F 69 /r	不影响标志位	反紧缩高位，字到双字	PUNPCKHWD XMM6，XMM7
PUNPCKHDQ	PUNPCKHDQ mm1, mm2/m64	0F 6A /r	不影响标志位	反紧缩高位，双字到四字
PUNPCKHDQ	PUNPCKHDQ xmm1,xmm2/m128	66 0F 6A /r	不影响标志位	反紧缩高位，双字到四字	PUNPCKHDQ XMM6，XMM7
PUNPCKHQDQ	PUNPCKHQDQ xmm1,xmm2/m128	66 0F 6D /r	不影响标志位	反紧缩高位，四字到八字
PUNPCKLBW	PUNPCKLBW mm, mm/m64	0F 60 /r	不影响标志位	反紧缩低位，字节到字
PUNPCKLBW	PUNPCKLBW xmm1,xmm2/m128	66 0F 60 /r	不影响标志位	反紧缩低位，字节到字	PUNPCKLBW XMM6，XMM7
PUNPCKLWD	PUNPCKLWD mm, mm/m64	0F 61 /r	不影响标志位	反紧缩低位，字到双字
PUNPCKLWD	PUNPCKLWD xmm1,xmm2/m128	66 0F 61 /r	不影响标志位	反紧缩低位，字到双字	PUNPCKLWD XMM6，XMM7
PUNPCKLDQ	PUNPCKLDQ mm1, mm2/m64	0F 62 /r	不影响标志位	反紧缩低位，双字到四字
PUNPCKLDQ	PUNPCKLDQ xmm1,xmm2/m128	66 0F 62 /r	不影响标志位	反紧缩低位，双字到四字	PUNPCKLDQ XMM6，XMM7
PUNPCKLQDQ	PUNPCKLQDQ xmm1, xmm2/m128	66 0F 6C /r	不影响标志位	反紧缩低位，四字到八字
PUSH	PUSH r/m16	FF /6	不影响标志位	16位数据压栈	PUSH WORD PTR [006387EA]
	PUSH r/m32	FF /6		32位数据压栈	PUSH DWORD PTR [006387EA]
	PUSH r16	50+rw		16位寄存器数据压栈	PUSH AX
	PUSH r32	50+rd		32位寄存器数据压栈	PUSH EAX
	PUSH imm8	6A		8位立即数据压栈	PUSH EA
	PUSH imm16	68		16位立即数据压栈	PUSH 87EA
	PUSH imm32	58		32位立即数据压栈	PUSH 006387EA
	PUSH CS	0E		寄存器CS数据压栈	PUSH CS
	PUSH SS	16		寄存器SS数据压栈	PUSH SS
	PUSH DS	1E		寄存器DS数据压栈	PUSH DS
	PUSH ES	06		寄存器ES数据压栈	PUSH ES
	PUSH FS	0F A0		寄存器FS数据压栈	PUSH FS
	PUSH GS	0F A8		寄存器GS数据压栈	PUSH GS
PUSHA	PUSHA	60	不影响标志位	压栈全部16位通用寄存器：AX, CX, DX, BX, SP, BP, SI, DI	PUSHA
PUSHAD	PUSHAD	60	不影响标志位	压栈全部32位通用寄存器：EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI	PUSHAD
PUSHF	PUSHF	9C	设置所有标志位	压栈16位标志寄存器	PUSHF
PUSHFD	PUSHFD	9C	设置所有标志位	压栈32位标志寄存器	PUSHFD
PXOR	PXOR mm, mm/m64	0F EF /r	不影响标志位	逻辑异或操作
PXOR	PXOR xmm1,xmm2/m128	66 0F EF /r	不影响标志位	逻辑异或操作	PXOR XMM6，XMM7
RCL	RCL r/m8, 1	D0 /2	CF(或OF)被改变	带进位循环左移1次	RCL AL，1
	RCL r/m8, CL	D2 /2		带进位循环左移CL次	RCL AL，CL
	RCL r/m8, imm8	C0 /2 ib		带进位循环左移imm8次	RCL AL，03
	RCL r/m16, 1	D1 /2		带进位循环左移1次	RCL AX，1
	RCL r/m16, CL	D3 /2		带进位循环左移CL次	RCL AX，CL
	RCL r/m16, imm8	C1 /2 ib		带进位循环左移imm8次	RCL AX，03
	RCL r/m32, 1	D1 /2		带进位循环左移1次	RCL EAX，1
	RCL r/m32, CL	D3 /2		带进位循环左移CL次	RCL EAX，CL
	RCL r/m32, imm8	C1 /2 ib		带进位循环左移imm8次	RCL EAX，03
RCR	RCR r/m8, 1	D0 /3	CF(或OF)被改变	带进位循环右移1次	RCR AL，1
	RCR r/m8, CL	D2 /3		带进位循环右移CL次	RCR AL，CL
	RCR r/m8, imm8	C0 /3 ib		带进位循环右移imm8次	RCR AL，03
	RCR r/m16, 1	D1 /3		带进位循环右移1次	RCR AX，1
	RCR r/m16, CL	D3 /3		带进位循环右移CL次	RCR AX，CL
	RCR r/m16, imm8	C1 /3 ib		带进位循环右移imm8次	RCR AX，03
	RCR r/m32, 1	D1 /3		带进位循环右移1次	RCR EAX，1
	RCR r/m32, CL	D3 /3		带进位循环右移CL次	RCR EAX，CL
	RCR r/m32, imm8	C1 /3 ib		带进位循环右移imm8次	RCR EAX，03
ROL	ROL r/m8, 1	D0 /0	CF(或OF)被改变	循环左移1次	ROL AL，1
	ROL r/m8, CL	D2 /0		循环左移CL次	ROL AL，CL
	ROL r/m8, imm8	C0 /0 ib		循环左移imm8次	ROL AL，03
	ROL r/m16, 1	D1 /0		循环左移1次	ROL AX，1
	ROL r/m16, CL	D3 /0		循环左移CL次	ROL AX，CL
	ROL r/m16, imm8	C1 /0 ib		循环左移imm8次	ROL AX，03
	ROL r/m32, 1	D1 /0		循环左移1次	ROL EAX，1
	ROL r/m32, CL	D3 /0		循环左移CL次	ROL EAX，CL
	ROL r/m32, imm8	C1 /0 ib		循环左移imm8次	ROL EAX，03
ROR	ROR r/m8, 1	D0 /1	CF(或OF)被改变	循环右移1次	ROR AL，1
	ROR r/m8, CL	D2 /1		循环右移CL次	ROR AL，CL
	ROR r/m8, imm8	C0 /1 ib		循环右移imm8次	ROR AL，03
	ROR r/m16, 1	D1 /1		循环右移1次	ROR AX，1
	ROR r/m16, CL	D3 /1		循环右移CL次	ROR AX，CL
	ROR r/m16, imm8	C1 /1 ib		循环右移imm8次	ROR AX，03
	ROR r/m32, 1	D1 /1		循环右移1次	ROR EAX，1
	ROR r/m32, CL	D3 /1		循环右移CL次	ROR EAX，CL
	ROR r/m32, imm8	C1 /1 ib		循环右移imm8次	ROR EAX，03
RDMSR	RDMSR	0F 32	不影响标志位	把ECX指定的模型专用寄存器内容送EDX:EAX	RDMSR
RDPMC	RDPMC	0F 33	不影响标志位	把ECX指定的性能监测计数器内容送EDX:EAX	RDPMC
RDTSC	RDTSC	0F 31	不影响标志位	读时间标记计数器到EDX:EAX	RDTSC
REP	REP INS r/m8, DX	F3 6C	不影响标志位	从DX指定的端口读(E)CX个字节(BYTE)到ES:[(E)DI]
	REP INS r/m16, DX	F3 6D		从DX指定的端口读(E)CX个字(WORD)到ES:[(E)DI]
	REP INS r/m32, DX	F3 6D		从DX指定的端口读(E)CX个双字(DWORD)到ES:[(E)DI]
	REP MOVS m8, m8	F3 A4		连续字符串传送，每次传送1个字节，传送(E)CX次	REP MOVS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REP MOVS m16, m16	F3 A5		连续字符串传送，每次传送1个字，传送(E)CX次	REP MOVS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REP MOVS m32, m32	F3 A5		连续字符串传送，每次传送1个双字，传送(E)CX次	REP MOVS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REP OUTS DX,r/m8	F3 6E		将DS:[(E)SI]处的(E)CX个字节输出到DX指定的端口
	REP OUTS DX,r/m16	F3 6F		将DS:[(E)SI]处的(E)CX个字输出到DX指定的端口
	REP OUTS DX,r/m32	F3 6F		将DS:[(E)SI]处的(E)CX个双字输出到DX指定的端口
	REP LODS AL	F3 AC		将地址DS:[(E)SI]处的(E)CX个字节装入AL
	REP LODS AX	F3 AD		将地址DS:[(E)SI]处的(E)CX个字装入AX
	REP LODS EAX	F3 AD		将地址DS:[(E)SI]处的(E)CX个双字装入EAX
	REP STOS m8	F3 AA		用AL填充地址ES:[(E)DI]处的(E)CX个字节
	REP STOS m16	F3 AB		用AX填充地址ES:[(E)DI]处的(E)CX个字
	REP STOS m32	F3 AB		用EAX填充地址ES:[(E)DI]处的(E)CX个双字
REPE	REPE CMPS m8, m8	F3 A6	设置 AF CF OF PF SF ZF	比较字符串，每次比较1个字节，直到不相等字节停止	REPE CMPS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REPE CMPS m16, m16	F3 A7		比较字符串，每次比较1个字，直到不相等字停止	REPE CMPS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REPE CMPS m32, m32	F3 A7		比较字符串，每次比较1个双字，直到不相等双字停止	REPE CMPS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REPE SCAS m8	F3 AE		扫描字符串ES:[(E)DI]中的AL字节值，遇到非AL值停止	REPE SCAS STRING1
	REPE SCAS m16	F3 AF		扫描字符串ES:[(E)DI]中的AX字值，遇到非AX值停止	REPE CMPS STRING1
	REPE SCAS m32	F3 AF		扫描字符串ES:[(E)DI]中的EAX双字值，遇到非EAX值停止	REPE CMPS STRING1
REPNE	REPNE CMPS m8, m8	F2 A6	设置 AF CF OF PF SF ZF	比较字符串，每次比较1个字节，直到相等字节停止	REPNE CMPS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REPNE CMPS m16, m16	F2 A7		比较字符串，每次比较1个字，直到相等字停止	REPNE CMPS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REPNE CMPS m32, m32	F2 A7		比较字符串，每次比较1个双字，直到相等双字停止	REPNE CMPS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REPNE SCAS m8	F2 AE		扫描字符串ES:[(E)DI]中的AL字节值，遇到AL值停止	REPNE SCAS STRING1
	REPNE SCAS m16	F2 AF		扫描字符串ES:[(E)DI]中的AX字值，遇到AX值停止	REPNE CMPS STRING1
	REPNE SCAS m32	F2 AF		扫描字符串ES:[(E)DI]中的EAX双字值，遇到EAX值停止	REPNE CMPS STRING1
REPZ	REPZ CMPS m8, m8	F3 A6	设置 AF CF OF PF SF ZF	比较字符串，每次比较1个字节，直到不相等字节停止	REPZ CMPS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REPZ CMPS m16, m16	F3 A7		比较字符串，每次比较1个字，直到不相等字停止	REPZ CMPS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REPZ CMPS m32, m32	F3 A7		比较字符串，每次比较1个双字，直到不相等双字停止	REPZ CMPS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REPZ SCAS m8	F3 AE		扫描字符串ES:[(E)DI]中的AL字节值，遇到非AL值停止	REPZ SCAS STRING1
	REPZ SCAS m16	F3 AF		扫描字符串ES:[(E)DI]中的AX字值，遇到非AX值停止	REPZ CMPS STRING1
	REPZ SCAS m32	F3 AF		扫描字符串ES:[(E)DI]中的EAX双字值，遇到非EAX值停止	REPZ CMPS STRING1
REPNZ	REPNZ CMPS m8, m8	F2 A6	设置 AF CF OF PF SF ZF	比较字符串，每次比较1个字节，直到相等字节停止	REPNZ CMPS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REPNZ CMPS m16, m16	F2 A7		比较字符串，每次比较1个字，直到相等字停止	REPNZ CMPS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REPNZ CMPS m32, m32	F2 A7		比较字符串，每次比较1个双字，直到相等双字停止	REPNZ CMPS STRING1, STRING2 ；源串DS:[(E)SI]，目的串：ES:[(E)DI]
	REPNZ SCAS m8	F2 AE		扫描字符串ES:[(E)DI]中的AL字节值，遇到AL值停止	REPNZ SCAS STRING1
	REPNZ SCAS m16	F2 AF		扫描字符串ES:[(E)DI]中的AX字值，遇到AX值停止	REPNZ CMPS STRING1
	REPNZ SCAS m32	F2 AF		扫描字符串ES:[(E)DI]中的EAX双字值，遇到EAX值停止	REPNZ CMPS STRING1
RET	RET	C3	恢复压栈的标志位	子过程返回(Near)	RET
	RET	CB		子过程返回(Far)	RET
	RET imm16	C2 iw		子过程返回(Near)，并从堆栈弹出imm16字节	RET 08
	RET imm16	CA iw		子过程返回(Far)，并从堆栈弹出imm16字节	RET 08
RSM	RSM	0F AA	恢复所有标志位	从系统管理模式返回	RSM
SAHF	SAHF	9E	设置SF ZF AF PF CF	装入AH到标志寄存器，格式：(SF:ZF:0:AF:0:PF:1:CF)←AH	SAHF
SAL	SAL r/m8, 1	D0 /4	CF(或OF)被改变	算术左移1次(乘法：r/m8=r/m8*2)	SAL AL，1
	SAL r/m8, CL	D2 /4		算术左移CL次(乘法：r/m8=r/m8*(2^CL))	SAL AL，CL
	SAL r/m8, imm8	C0 /4 ib		算术左移imm8次(乘法：r/m8=r/m8*(2^imm8))	SAL AL，03
	SAL r/m16, 1	D1 /4		算术左移1次(乘法：r/m16=r/m16*2)	SAL AX，1
	SAL r/m16, CL	D3 /4		算术左移CL次(乘法：r/m16=r/m16*(2^CL))	SAL AX，CL
	SAL r/m16, imm8	C1 /4 ib		算术左移imm8次(乘法：r/m16=r/m16*(2^imm8))	SAL AX，03
	SAL r/m32, 1	D1 /4		算术左移1次(乘法：r/m32=r/m32*2)	SAL EAX，1
	SAL r/m32, CL	D3 /4		算术左移CL次(乘法：r/m32=r/m32*(2^CL))	SAL EAX，CL
	SAL r/m32, imm8	C1 /4 ib		算术左移imm8次(乘法：r/m32=r/m32*(2^imm8))	SAL EAX，03
SAR	SAR r/m8, 1	D0 /7	CF(或OF)被改变	算术右移1次(有符号除法：r/m8=r/m8 / 2)	SAR AL，1
	SAR r/m8, CL	D2 /7		算术右移CL次(有符号除法：r/m8=r/m8 / (2^CL))	SAR AL，CL
	SAR r/m8, imm8	C0 /7 ib		算术右移imm8次(有符号除法：r/m8=r/m8 / (2^imm8))	SAR AL，03
	SAR r/m16, 1	D1 /7		算术右移1次(有符号除法：r/m16=r/m16 / 2)	SAR AX，1
	SAR r/m16, CL	D3 /7		算术右移CL次(有符号除法：r/m16=r/m16 / (2^CL))	SAR AX，CL
	SAR r/m16, imm8	C1 /7 ib		算术右移imm8次(有符号除法：r/m16=r/m16 / (2^imm8))	SAR AX，03
	SAR r/m32, 1	D1 /7		算术右移1次(有符号除法：r/m32=r/m32 / 2)	SAR EAX，1
	SAR r/m32, CL	D3 /7		算术右移CL次(有符号除法：r/m32=r/m32 / (2^CL))	SAR EAX，CL
	SAR r/m32, imm8	C1 /7 ib		算术右移imm8次(有符号除法：r/m32=r/m32 / (2^imm8))	SAR EAX，03
SHL	SHL r/m8, 1	D0 /4	CF(或OF)被改变	逻辑左移1次(乘法：r/m8=r/m8*2)	SHL AL，1
	SHL r/m8, CL	D2 /4		逻辑左移CL次(乘法：r/m8=r/m8*(2^CL))	SHL AL，CL
	SHL r/m8, imm8	C0 /4 ib		逻辑左移imm8次(乘法：r/m8=r/m8*(2^imm8))	SHL AL，03
	SHL r/m16, 1	D1 /4		逻辑左移1次(乘法：r/m16=r/m16*2)	SHL AX，1
	SHL r/m16, CL	D3 /4		逻辑左移CL次(乘法：r/m16=r/m16*(2^CL))	SHL AX，CL
	SHL r/m16, imm8	C1 /4 ib		逻辑左移imm8次(乘法：r/m16=r/m16*(2^imm8))	SHL AX，03
	SHL r/m32, 1	D1 /4		逻辑左移1次(乘法：r/m32=r/m32*2)	SHL EAX，1
	SHL r/m32, CL	D3 /4		逻辑左移CL次(乘法：r/m32=r/m32*(2^CL))	SHL EAX，CL
	SHL r/m32, imm8	C1 /4 ib		逻辑左移imm8次(乘法：r/m32=r/m32*(2^imm8))	SHL EAX，03
SHR	SHR r/m8, 1	D0 /5	CF(或OF)被改变	逻辑右移1次(无符号除法：r/m8=r/m8 / 2)	SHR AL，1
	SHR r/m8, CL	D2 /5		逻辑右移CL次(无符号除法：r/m8=r/m8 / (2^CL))	SHR AL，CL
	SHR r/m8, imm8	C0 /5 ib		逻辑右移imm8次(无符号除法：r/m8=r/m8 / (2^imm8))	SHR AL，03
	SHR r/m16, 1	D1 /5		逻辑右移1次(无符号除法：r/m16=r/m16 / 2)	SHR AX，1
	SHR r/m16, CL	D3 /5		逻辑右移CL次(无符号除法：r/m16=r/m16 / (2^CL))	SHR AX，CL
	SHR r/m16, imm8	C1 /5 ib		逻辑右移imm8次(无符号除法：r/m16=r/m16 / (2^imm8))	SHR AX，03
	SHR r/m32, 1	D1 /5		逻辑右移1次(无符号除法：r/m32=r/m32 / 2)	SHR EAX，1
	SHR r/m32, CL	D3 /5		逻辑右移CL次(无符号除法：r/m32=r/m32 / (2^CL))	SHR EAX，CL
	SHR r/m32, imm8	C1 /5 ib		逻辑右移imm8次(无符号除法：r/m32=r/m32 / (2^imm8))	SHR EAX，03
SBB	SBB AL, imm8	1C ib	设置 AF CF OF SF PF ZF	带借位减法	SBB AL, 1F
	SBB AX, imm16	1D iw			SBB AX, 4F80
	SBB EAX, imm32	1D id			SBB EAX, 00004F80
	SBB r/m8, imm8	80 /3 ib			SBB BYTE PTR [006387EA], 39
	SBB r/m16,imm16	81 /3 iw			SBB WORD PTR [006387EA], 1039
	SBB r/m32,imm32	81 /3 id			SBB DWORD PTR [006387EA], 00001039
	SBB r/m16,imm8	83 /3 ib			SBB WORD PTR [006387EA], 39
	SBB r/m32,imm8	83 /3 ib			SBB DWORD PTR [006387EA], 39
	SBB r/m8,r8	18 /r			SBB [006387EA], AL
	SBB r/m16,r16	19 /r			SBB [006387EA], AX
	SBB r/m32,r32	19 / r			SBB [006387EA], EAX
	SBB r8,r/m8	1A /r			SBB AL, [006387EA]
	SBB r16,r/m16	1B /r			SBB AX, [006387EA]
	SBB r32,r/m32	1B /r			SBB EAX, [006387EA]
SCAS	SCAS m8	AE	设置OF SF ZF AF PF CF	用AL中的字节值扫描字符串ES:(E)DI，然后设置标志位
	SCAS m16	AF		用AX中的字值扫描字符串ES:(E)DI，然后设置标志位
	SCAS m32	AF		用EAX中的双字值扫描字符串ES:(E)DI，然后设置标志位
SCASB	SCASB	AE	设置OF SF ZF AF PF CF	用AL中的字节值扫描字符串ES:(E)DI，然后设置标志位	SCASB
SCASW	SCASW	AF	设置OF SF ZF AF PF CF	用AX中的字值扫描字符串ES:(E)DI，然后设置标志位	SCASW
SCASD	SCASD	AF	设置OF SF ZF AF PF CF	用EAX中的双字值扫描字符串ES:(E)DI，然后设置标志位	SCASD
SETcc	SETA r/m8	0F 97	高于(CF=0 and ZF=0)	条件设置指令，如果条件满足则r/m8=1，否则r/m8=0	SETA AL
	SETAE r/m8	0F 93	高于等于(CF=0)		SETAE AL
	SETB r/m8	0F 92	低于(CF=1)		SETB AL
	SETBE r/m8	0F 96	低于等于(CF=1 or ZF=1)		SETBE AL
	SETC r/m8	0F 92	有进位(CF=1)		SETC AL
	SETE r/m8	0F 94	等于(ZF=1)		SETE AL
	SETG r/m8	0F 9F	大于(ZF=0 and SF=OF)		SETG AL
	SETGE r/m8	0F 9D	大于等于(SF=OF)		SETGE AL
	SETL r/m8	0F 9C	小于(SF<>OF)		SETL AL
	SETLE r/m8	0F 9E	小于等于(ZF=1 or SF<>OF)		SETLE AL
	SETNA r/m8	0F 96	不高于(CF=1 or ZF=1)		SETNA AL
	SETNAE r/m8	0F 92	不高等于(CF=1)		SETNAE AL
	SETNB r/m8	0F 93	不低于(CF=0)		SETNB AL
	SETNBE r/m8	0F 97	不低等于(CF=0 and ZF=0)		SETNBE AL
	SETNC r/m8	0F 93	无进位(CF=0)		SETNC AL
	SETNE r/m8	0F 95	不等于(ZF=0)		SETNE AL
	SETNG r/m8	0F 9E	不大于(ZF=1 or SF<>OF)		SETNG AL
	SETNGE r/m8	0F 9C	不大等于(SF<>OF)		SETNGE AL
	SETNL r/m8	0F 9D	不小于(SF=OF)		SETNL AL
	SETNLE r/m8	0F 9F	不小等于(ZF=0 and SF=OF)		SETNLE AL
	SETNO r/m8	0F 91	无溢出(OF=0)		SETNO AL
	SETNP r/m8	0F 9B	非偶数(PF=0)		SETNP AL
	SETNS r/m8	0F 99	非负数(SF=0)		SETNS AL
	SETNZ r/m8	0F 95	非零(ZF=0)		SETNZ AL
	SETO r/m8	0F 90	溢出(OF=1)		SETO AL
	SETP r/m8	0F 9A	偶数(PF=1)		SETP AL
	SETPE r/m8	0F 9A	偶数(PF=1)		SETPE AL
	SETPO r/m8	0F 9B	奇数(PF=0)		SETPO AL
	SETS r/m8	0F 98	负数(SF=1)		SETS AL
	SETZ r/m8	0F 94	为零(ZF=1)		SETZ AL
SGDT	SGDT m	0F 01 /0	不影响标志位	保存全局描述符表寄存器到内存m处	SGDT [EBP]
SIDT	SIDT m	0F 01 /1	不影响标志位	保存中断描述符表寄存器到内存m处	SIDT [ESI]
SLDT	SLDT r/m16	0F 00 /0	不影响标志位	保存LDT选择子到r/m16	SLDT SI
SLDT	SLDT r/m32	0F 00 /0	不影响标志位	保存LDT选择子到r/m32	SLDT ESI
SHLD	SHLD r/m16, r16, imm8	0F A4	设置CF SF ZF PF AF OF	双精度左移	SHLD AX，BX，3
	SHLD r/m16, r16, CL	0F A5			SHLD AX，BX，CL
	SHLD r/m32, r32, imm8	0F A4			SHLD EAX，EBX，3
	SHLD r/m32, r32, CL	0F A5			SHLD EAX，EBX，CL
SHRD	SHRD r/m16, r16, imm8	0F AC	设置CF SF ZF PF AF OF	双精度右移	SHRD AX，BX，3
	SHRD r/m16, r16, CL	0F AD			SHRD AX，BX，CL
	SHRD r/m32, r32, imm8	0F AC			SHRD EAX，EBX，3
	SHRD r/m32, r32, CL	0F AD			SHRD EAX，EBX，CL
SMSW	SMSW r/m16	0F 01 /4	不影响标志位	保存机器状态字到r/m16	SMSW SI
SMSW	SMSW r32/m16	0F 01 /4	不影响标志位	保存机器状态字到r32/m16	SMSW ESI
STC	STC	F9	设置CF	设置CF=1	STC
STD	STD	FD	设置DF	设置DF=1	STD
STI	STI	FB	设置IF	设置IF=1，开中断	STI
STOS	STOS m8	AA	不影响标志位	将AL保存到地址ES:(E)DI
	STOS m16	AB		将AX保存到地址ES:(E)DI
	STOS m32	AB		将EAX保存到地址ES:(E)DI
STOSB	STOSB	AA	不影响标志位	将AL保存到地址ES:(E)DI	STOSB
STOSW	STOSW	AB	不影响标志位	将AX保存到地址ES:(E)DI	STOSW
STOSD	STOSD	AB	不影响标志位	将EAX保存到地址ES:(E)DI	STOSD
STR	STR r/m16	0F 00 /1	不影响标志位	保存任务寄存器到r/m16	STR AX
SUB	SUB AL, imm8	2C ib	设置 AF CF OF SF PF ZF	减法	SUB AL, 1F
	SUB AX, imm16	2D iw			SUB AX, 4F80
	SUB EAX, imm32	2D id			SUB EAX, 00004F80
	SUB r/m8, imm8	80 /5 ib			SUB BYTE PTR [006387EA], 39
	SUB r/m16,imm16	81 /5 iw			SUB WORD PTR [006387EA], 1039
	SUB r/m32,imm32	81 /5 id			SUB DWORD PTR [006387EA], 00001039
	SUB r/m16,imm8	83 /5 ib			SUB WORD PTR [006387EA], 39
	SUB r/m32,imm8	83 /5 ib			SUB DWORD PTR [006387EA], 39
	SUB r/m8,r8	28 /r			SUB [006387EA], AL
	SUB r/m16,r16	29 /r			SUB [006387EA], AX
	SUB r/m32,r32	29 / r			SUB [006387EA], EAX
	SUB r8,r/m8	2A /r			SUB AL, [006387EA]
	SUB r16,r/m16	2B /r			SUB AX, [006387EA]
	SUB r32,r/m32	2B /r			SUB EAX, [006387EA]
SYSENTER	SYSENTER	0F 34	设置VM IF RF	快速调用系统0级过程(用于系统3级应用程序)，配合SYSEXIT使用
SYSEXIT	SYSEXIT	0F 35	不影响标志位	快速返回到系统3级用户代码，配合SYSENTER使用
TEST	TEST AL, imm8	A8 ib	设置 CF OF PF SF ZF	逻辑与测试，但是不改变目的操作数，只设置相关标志位	TEST AL, 1F
	TEST AX, imm16	A9 iw			TEST AX, 4F80
	TEST EAX, imm32	A9 id			TEST EAX, 00004F80
	TEST r/m8, imm8	F6 /0 ib			TEST BYTE PTR [006387EA], 39
	TEST r/m16,imm16	F7 /0 ib			TEST WORD PTR [006387EA], 1039
	TEST r/m32,imm32	F7 /0 ib			TEST DWORD PTR [006387EA], 00001039
	TEST r/m8,r8	84 /r			TEST BYTE PTR [006387EA], AL
	TEST r/m16,r16	85 /r			TEST WORD PTR [006387EA], AX
	TEST r/m32,r32	85 /r			TEST DWORD PTR [006387EA], EAX
UD2	UD2	0F 0B	不影响标志位	产生无效代码异常，用于软件测试	UD2
VERR	VERR	0F 00 /4	设置ZF	如果目标选择子对应段可读，则ZF置1	VERR
VERW	VERW	0F 00 /5	设置ZF	如果目标选择子对应段可写，则ZF置1	VERW
WAIT	WAIT	9B	C0，C1, C2, C3 未定义	等待，检查非屏蔽浮点异常	WAIT
WBINVD	WBINVD	0F 09	不影响标志位	写回内部CACHE并使之失效	WBINVD
WRMSR	WRMSR	0F 30	不影响标志位	把EDX:EAX的内容写入ECX指定的模型专用寄存器	WRMSR
XADD	XADD r/m8, r8	0F C0 /r	设置 CF PF AF SF ZF OF	目的操作数和源操作数相加，并使源操作数保存目的操作数的值	XADD AL，BL
	XADD r/m16, r16	0F C1 /r			XADD AX，BX
	XADD r/m32, r32	0F C1 /r			XADD EAX，EBX
XCHG	XCHG AX, r16	90+rw	不影响标志位	目的操作数和源操作数的值交换	XCHG AX，BX
	XCHG r16, AX	90+rw			XCHG CX，AX
	XCHG EAX, r32	90+rd			XCHG EAX，EBX
	XCHG r32, EAX	90+rd			XCHG ECX，EAX
	XCHG r/m8, r8	86 /r			XCHG [006387EA]，BL
	XCHG r8, r/m8	86 /r			XCHG AX，[006387EA]
	XCHG r/m16, r16	87 /r			XCHG [006387EA]，BX
	XCHG r16, r/m16	87 /r			XCHG AX，[006387EA]
	XCHG r/m32, r32	87 /r			XCHG [006387EA]，EBX
	XCHG r32, r/m32	87 /r			XCHG EAX，[006387EA]
XLAT	XLAT m8	D7	不影响标志位	换码：DS:[(E)BX + unsigned AL]←AL
XLATB	XLATB	D7	不影响标志位	换码：DS:[(E)BX + unsigned AL]←AL	XLATB
XOR	XOR AL, imm8	34 ib	设置 CF OF PF SF ZF	逻辑异或	XOR AL, 1F
	XOR AX, imm16	35 iw			XOR AX, 4F80
	XOR EAX, imm32	35 id			XOR EAX, 00004F80
	XOR r/m8, imm8	80 /6 ib			XOR BYTE PTR [006387EA], 39
	XOR r/m16,imm16	81 /6 iw			XOR WORD PTR [006387EA], 1039
	XOR r/m32,imm32	81 /6 id			XOR DWORD PTR [006387EA], 00001039
	XOR r/m16,imm8	83 /6 ib			XOR WORD PTR [006387EA], 39
	XOR r/m32,imm8	83 /6 ib			XOR DWORD PTR [006387EA], 39
	XOR r/m8,r8	30 /r			XOR BYTE PTR [006387EA], AL
	XOR r/m16,r16	31 /r			XOR WORD PTR [006387EA], AX
	XOR r/m32,r32	31 /r			XOR DWORD PTR [006387EA], EAX
	XOR r8,r/m8	32 /r			XOR AL, [006387EA]
	XOR r16,r/m16	33 /r			XOR AX, [006387EA]
	XOR r32,r/m32	33 /r			XOR EAX, [006387EA]

上表中所使用符号的说明

/digit -- 0到7之间的数字，用于只使用寄存器/内存操作数的指令的 ModR/M字节，作为指令扩展码

/r -- 表明指令的ModR/M字节既包含寄存器操作数，又包含内存操作数

cb -- 相对于下一条指令的字节偏移值

cw -- 相对于下一条指令的字偏移值

cd -- 相对于下一条指令的双字偏移值

cp -- 绝对远指针

ib, iw, id -- ib：1字节立即数；iw：2字节立即数；id：4字节立即数

+rb, +rw, +rd -- 寄存器代码，从0到7，被加到操作数字节：


             rb     rw     rd
          ----------------------
           AL = 0 AX = 0 EAX = 0
           CL = 1 CX = 1 ECX = 1
           DL = 2 DX = 2 EDX = 2
           BL = 3 BX = 3 EBX = 3
           AH = 4 SP = 4 ESP = 4
           CH = 5 BP = 5 EBP = 5
           DH = 6 SI = 6 ESI = 6
           BH = 7 DI = 7 EDI = 7

+i -- 用于浮点指令的数字，表示ST(i)之一

rel8 -- 8位相对地址，范围：-128 ~ 127

rel16, rel32 -- 同一段内的相对地址

ptr16:16，ptr16:32 -- 远指针，典型应用于跨段指令

r8 -- 8位通用寄存器

r16 -- 16位通用寄存器

r32 -- 32位通用寄存器

imm8 -- 8位立即数

imm16 -- 16位立即数

imm32 -- 32位立即数

r/m8 -- 8位通用寄存器或内存字节

r/m16 -- 16位通用寄存器或内存字节

r/m32 -- 32位通用寄存器或内存字节

m -- 16位或32位内存操作数

m8 -- 由DS:(E)SI或ES:(E)DI指向的内存字节

m16 -- 由DS:(E)SI或ES:(E)DI指向的内存字

m32 -- 由DS:(E)SI或ES:(E)DI指向的内存双字

m64 -- 内存四字，仅用于CMPXCHG8B指令

m16:16, m16:32 -- 包含两个数据的内存指针操作数，引号前面的是段地址，引号后面的是偏移地址

m16&32, m16&16, m32&32 -- 包含数据对的内存操作数

moffs8, moffs16, moffs32 -- 分别表示类型为字节、字、双字的内存变量

Sreg -- 段寄存器，ES=0, CS=1, SS=2, DS=3, FS=4, GS=5

m32real, m64real, m80real -- 单精度、双精度、扩展双精度内存浮点操作数

m16int, m32int, m64int -- 字型、双字型、四字型内存整数操作数

ST or ST(0) -- FPU寄存器堆栈栈顶元素

ST(i) -- 从FPU寄存器堆栈栈顶数起的第i个元素，i = 0,1,2,3,4,5,6,7

mm -- MMX寄存器，从MM0到MM7

mm/m32 -- MMX寄存器的低32位或32位内存操作数

mm/m64 -- MMX寄存器或64位内存操作数

xmm -- 128位XMM寄存器，从XMM0到XMM7

xmm/m32 -- XMM寄存器或32位内存操作数

xmm/m64 -- XMM寄存器或64位内存操作数

xmm/m128 -- XMM寄存器或128位内存操作数

Rational Rose使用点滴积累

遇君阁 — Wed, 16 Apr 2008 08:41:00 GMT

Ø 如何定义namespace

1．创建一个Package，，命名为Namespaces。

2．在刚才建立的Package下建立一个GClass类，定义一个int i和getvalue成员函数。如图：

3．双击Namespaces package，并在“ANSI C++”标签里将IsNamspace属性置为true，如图：

4．生成代码

Ø 正向工程与逆向工程

正向工程：

1).检查并创建模型中的类，比如创建类名为GClass的一个类；

2).在Component View里创建构件(component)；如：创建名字为NewPackageBody的component名称

3).双击刚才建立的构件（NewPackageBody），在弹出的Component Sepcification窗口中的Realizes标签页里右击你要分配的类，选择”assign”将类映射到构件，同时你需要在General标签页里将language选项设置成ANSI C++ ，如下图：

4).可以在Tools->ANSI C++->Open ANSI C++ Specification设置代码生成属性，如图：

5).选择类图和（或)构件图中要进行代码生成的类和构件；

6).选择Tools> ANSI C++>Code Generation或者右单击类和构件图标，选择ANSI C++>Generate Code…。

逆向工程：

1）在构件视图（Component View）中创建并命名新的构件(Component)，如：NewPackageBody；

2).双击新的构件（NewPackageBody）打开Component Specification窗口，将构件的实现语言改为ANSI C++，如图：

3).右单击新构件（NewPackageBody），选择快捷菜单中的ANSI； C++>Open ANSI C++ Specification…，打开构件ANSI C++ Specification窗口，如图：

4).在构件规范窗口的Files标签中添加源文件；

5).单击构件NewPackageBody，选择Tools>ANSI C++>Reverse engineer…，打开“选择要添加到模型中的类 ”的窗口；

6).选择要添加到模型中的类，单击Ok按钮，开始逆向工程。

Ø 定义模板类

1）检查并在模型中创建一个类，比如创建TAllocator；

2）双击在第一步中创建的类（TAllocator），出现Class Specification窗口，在General标签页中将Type设置为：ParameterizedClass，如图；

3）同时在Class Specification窗口的Detail标签页中的Formal Arguments中增加一个类型名T，类型为class，如图：

Ø 定义组合

1）检查并建立模型中的两个类，比如建立类A和类B；

2）使用聚合关系连接A和B；

3）双击那根聚合的连接线，在窗口Aggregation Specification中的Role B Detail中，将Containment of B设置成By Value的方式，如图：

using声明与using 指示符

遇君阁 — Wed, 16 Apr 2008 04:37:00 GMT

Ø using 声明

using 声明是以关键字using 开头后面是名字空间成员名, 但是一次只能引入一个名字空间成员.。使用using声明的直接效果是允许程序员访问命名空间中的名字,而不需要加前缀namespace_name::。同时using 声明同其他声明的行为一样：它有一个域，它引入的名字从该声明开始直到其所在的域结束都是可见的。using 声明可以出现在全局域和任意名字空间中，同时它也可以出现在局部域中。

格式：using namespace::name;

Using声明的一个经常用法是使被子类覆盖的父类中的方法在子类中可见，如：

class Base {
private:
　int x;
public:
　virtual void mf1() = 0;
　virtual void mf1(int);
　virtual void mf2();
　void mf3();
　void mf3(double);
　...
};

class Derived: public Base {
public:
// make all things in Base named mf1 and mf3

// visible (and public) in Derived’s scope

　using Base::mf1; 　

using Base::mf3; 　

   virtual void mf1();
   void mf3();
   void mf4();
...
};

Ø using指示符

using指示符：是使用整个名字空间，其直接作用是使该名词空间下的所名字可见。

格式：using namespace namespace_name

　　using指示符语句可以加在程序文件的几乎任何地方，包括文件开头（#include语句之前）、函数内部。不过用using指定的名字空间作用域（生命周期）受using语句所在位置的生命周期约束。如，函数内部使用“using namespace myspacename;”则 myspacename仅在该函数内部可见。

可以用using语句指定多个名字空间，使得多个名字空间同时可见。但这增加了名字污染的可能性，而且只有在使用各名字空间相同成员时由多个using指示符引起的二义性错误才能被检测到，这将给程序的检测、扩展、移植带来很大的隐患。因此，应该尽量使用using声明而不是滥用using指示符。

附：

Ø Using声明与一般声明的区别

它们之间的区别在于，Using声明只引入了一个名称，而一般声明在引入一个名称的同时，还告诉我们这个

名称的signature是什么样子的。所以这里又有必要说明一下如何声明一个命名空间里的对象或者函数：

// a.cpp

namespace example

{

// class declaration in namespace

class A;

// function declaration in namespace

int foo();

}