ָ

ָʽ		ָ						ִеĲ

1  ݴݺͶԳĲָ

FLD src			װʵst(0)	        				st(0) <- src (mem32/mem64/mem80)
FILD src		װst(0)						st(0) <- src (mem16/mem32/mem64)
FBLD src 		װBCDst(0)					st(0) <- src (mem80)

FLDZ			0.0װst(0)						st(0) <- 0.0
FLD1			1.0װst(0)						st(0) <- 1.0 
FLDPI			piװst(0)						st(0) <- ?(ie, pi)
FLDL2T			log2(10)װst(0)					st(0) <- log2(10)
FLDL2E			log2(e)װst(0)					st(0) <- log2(e)
FLDLG2			log10(2)װst(0)					st(0) <- log10(2)
FLDLN2			loge(2)װst(0)					st(0) <- loge(2)

FST dest		ʵst(0)dest					dest <- st(0) (mem32/mem64)
FSTP dest									dest <- st(0) (mem32/mem64/mem80)Ȼִһγջ
FIST dest		st(0)浽					dest	dest <- st(0) (mem32/mem64)
FISTP dest									dest <- st(0) (mem16/mem32/mem64)Ȼִһγջ	
FBST dest		st(0)BCD浽dest					dest <- st(0) (mem80) 
FBSTP dest 									dest<- st(0) (mem80)Ȼִһγջ

2Ƚָ	

FCOM			ʵȽ						־λΪ st(0) - st(1) Ľ־λ
FCOM op			ʵȽ						־λΪ st(0) - op (mem32/mem64)Ľ־λ
FICOM op		Ƚ						FlagsֵΪst(0)-op Ľop (mem16/mem32)
FICOMP op		Ƚ						st(0)opȽ op(mem16/mem32)ִһγջ
FTST 			 							st(0)0.0Ƚ
FUCOM st(i) 									Ƚst(0) st(i)                  [486]
FUCOMP st(i)									Ƚst(0) st(i)ִһγջ
FUCOMPP st(i)									Ƚst(0) st(i)ִγջ
FXAM  										Examine: Eyeball st(0) (set condition codes)

3ָ

ӷ

FADD			ʵ							st(0) <-st(0) + st(1)
FADD src									st(0) <-st(0) + src (mem32/mem64)
FADD st(i),st									st(i) <- st(i) + st(0)
FADDP st(i),st									st(i) <- st(i) + st(0)Ȼִһγջ
FIADD src 		һ						st(0) <-st(0) + src (mem16/mem32)
  	


FSUB			ȥһʵ						st(0) <- st(0) - st(1)
FSUB src									st(0) <-st(0) - src (reg/mem)
FSUB st(i),st									st(i) <-st(i) - st(0)
FSUBP st(i),st									st(i) <-st(i) - st(0)Ȼִһγջ
FSUBR st(i),st		һʵ						st(0) <- st(i) - st(0)
FSUBRP st(i),st  								st(0) <- st(i) - st(0)Ȼִһγջ
FISUB src		ȥһ						st(0) <- st(0) - src (mem16/mem32)
FISUBR src		һ						st(0) <- src - st(0) (mem16/mem32)
  	

˷ 

FMUL			һʵ						st(0) <- st(0) * st(1)
FMUL st(i)									st(0) <- st(0) * st(i)
FMUL st(i),st									st(i) <- st(0) * st(i)
FMULP st(i),st									st(i) <- st(0) * st(i)Ȼִһγջ
FIMUL src		һ						st(0) <- st(0) * src (mem16/mem32)
  	
 

FDIV  			һʵ						st(0) <-st(0) /st(1)
FDIV st(i)									st(0) <- st(0) /t(i)
FDIV st(i),st									st(i) <-st(0) /st(i)
FDIVP st(i),st									st(i) <-st(0) /st(i)Ȼִһγջ 
FIDIV src		һ						st(0) <- st(0) /src (mem16/mem32)
FDIVR st(i),st          ʵ						st(0) <- st(i) /st(0)
FDIVRP st(i),st									FDIVRP st(i),st
FIDIVR src								st(0) <- src /st(0) (mem16/mem32)
FSQRT			ƽ							st(0) <- sqrt st(0)
FSCALE  		2st(0)η						ST(0) <- ST(0)*(2^ST(1))
FXTRACT			Extract exponent:					st(0) <-exponent of st(0); and gets pushed 
										st(0) <-significand of st(0)

FPREM			ȡ							st(0) <-st(0) MOD st(1)
FPREM1			ȡIEEEͬFPREMʹIEEE׼[486]
FRNDINT 		ȡ룩					st(0) <- INT( st(0) ); depends on RC flag
FABS			ֵ 						st(0) <- ABS( st(0) ); removes sign
FCHS			ıλ(					st(0) <-st(0)
F2XM1			(2 ^ x)-1						st(0) <- (2 ^ st(0)) - 1
FYL2X 			Y * log2(X)						st(0)ΪYst(1)ΪXst(0)st(1)Ϊst(0) * log2( st(1) )ֵ
FCOS			ҺCos						st(0) <- COS( st(0) )
FPTAN			кtan						st(0) <- TAN( st(0) )
FPATAN			кarctan					st(0) <- ATAN( st(0) )
FSIN			Һsin						st(0) <- SIN( st(0) )
FSINCOS			sincos						st(0) <-SIN( st(0) )ѹst(1)
										st(0) <- COS( st(0) )
FYL2XP1			Y * log2(X+1)					st(0)ΪY st(1)ΪX st(0)st(1)Ϊst(0) * log2( st(1)+1 )ֵ

ָ

FINIT			ʼFPU
FSTSW AX		״ֵֵ̬AX					AX<- MSW
FSTSW dest 		״ֵֵ̬dest					dest<-MSW (mem16)
FLDCW src		srcװFPUĿ					FPU CW <-src (mem16)
FSTCW dest		FPUĿֱ浽dest					dest<- FPU CW
FCLEX  			쳣
FSTENV dest		滷ڴַdest ״̬֡֡־ֺ쳣ֵָ
FLDENV src		ڴַsrcװ뱣Ļ	
FSAVE dest		FPU״̬dest 94ֽ	
FRSTOR src		srcװFSAVEFPU״̬	
FINCSTP			FPUջֵָ					st(6) <-st(5); st(5) <-st(4),...,st(0) <-?
FDECSTP			FPUջֵָ					st(0) <-st(1); st(1) <-st(2),...,st(7) <-? 
FFREE st(i)  		־Ĵst(i)δʹ
FNOP 			ղͬCPUnop  					st(0) <-st(0)
WAIT/FWAIT  		ͬFPUCPUֹͣCPUУֱFPUɵǰ
FXCH			ָst(0)st(1)ֵ				st(0) <-st(1) 
										st(1) <- st(0) 		
	
	
	
  	תѩѧԺwww.pediy.com
                                                                          fisheep(fisheep@sohu.com)
MMXָ

  
1㣺
PADD[BWD] Ƽ[ֽڣ֣˫]
PADDS[B , W] зűͼ[ֽڣ]
PADDUS[B , W] ޷űͼ[ֽڣ]
PSUB[BWD] Ƽ[ֽڣ֣˫]
PSUBS[B,W] зűͼ[ֽڣ]
PSUBUS[D,W] ޷űͼֽڣ֡
PMULHW ֳ˺ȡλ
PMULLW ֳ˺ȡλ
PMADDWD ֳˣ
2Ƚϣ
PCMPEQ[B,W,D] ȽǷȡֽڣ֣˫֡
PCMPGT[B,W,D] ȽǷڡֽڣ֣˫֡
3ת
PACKUSWB ޷űѹֳֽڡ
PACKSS[WB,DW] зűѹ/˫ֳ/ֽ/֡
PUNPCKH[BW,WD,DQ] չλֽڣ֣˫ֳ֣˫֣4֡
PUNPCKL[BW,WD,DQ] չλֽڣ֣˫ֳ֣˫֣4֡
4߼㣺
PAND ߼
PANDN ߼
POR ߼
PXOR ߼
5λƣ
PSLL[W,D,Q] ߼[֣˫֣4]
PSRL[W,D,Q] ߼[֣˫֣4]
PSRA[W,D] ơ֣˫֡
7ݴͣ
MOV[D,Q] MMXĴ/˫/4֡
    8״̬
    EMMS MMX״̬
	

SSE4ָ

AAAASCII Adjust After Addition                                                                                              
AADASCII Adjust AX Before Division                                                                                       
AAMASCII Adjust AX After Multiply                                                                                          
AASASCII Adjust AL After Subtraction                                                                                    
ADCAdd with Carry                                                                                                                       
ADDAdd                                                                                                                                            
ADDPDAdd Packed Double-Precision Floating-Point Values                                           
ADDPSAdd Packed Single-Precision Floating-Point Values                                            
ADDSDAdd Scalar Double-Precision Floating-Point Values                                             
ADDSSAdd Scalar Single-Precision Floating-Point Values                                              
ADDSUBPDPacked Double-FP Add/Subtract                                                               
ADDSUBPSPacked Single-FP Add/Subtract                                                                         
AESENC/AESENCLAST- Perform One Round of an AES Encryption Flow                        
AESDEC/AESDECLAST- Perform One Round of an AES Decryption Flow                      
AESIMC- Perform the AES InvMixColumn Transformation                                                 
AESKEYGENASSIST - AES Round Key Generation Assist                                                     
ANDLogical AND                                                                                                                          
ANDPDBitwise Logical AND of Packed Double-Precision Floating-Point Values        
ANDPSBitwise Logical AND of Packed Single-Precision Floating-Point Values          
ANDNPDBitwise Logical AND NOT of Packed Double-Precision Floating-Point Values   
ANDNPSBitwise Logical AND NOT of Packed Single-Precision Floating-Point Values
ARPLAdjust RPL Field of Segment Selector                                                                         
BLENDPD  Blend Packed Double Precision Floating-Point Values                                
BLENDPS  Blend Packed Single Precision Floating-Point Values                                    
BLENDVPD  Variable Blend Packed Double Precision Floating-Point Values             
BLENDVPS  Variable Blend Packed Single Precision Floating-Point Values               
BOUNDCheck Array Index Against Bounds                                                                           
BSFBit Scan Forward                                                                                                                   
BSRBit Scan Reverse                                                                                                                   
BSWAPByte Swap                                                                                                                     
BTBit Test                                                                                                                                    
BTCBit Test and Complement                                                                                                
BTRBit Test and Reset                                                                                                            
BTSBit Test and Set                                                                                                                 
CALLCall Procedure                                                                                                                    
CBW/CWDE/CDQEConvert Byte to Word/Convert Word to Doubleword/Convert Doubleword to Quadword                                                                                       
CLCClear Carry Flag                                                                                                                  
CLDClear Direction Flag                                                                                                         
CLFLUSHFlush Cache Line                                                                                                       
CLI  Clear Interrupt Flag                                                                                                           
CLTSClear Task-Switched Flag in CR0                                                                                  
CMCComplement Carry Flag                                                                                                    
CMOVccConditional Move                                                                                                        
CMPCompare Two Operands                                                                                                 
CMPPDCompare Packed Double-Precision Floating-Point Values                               
CMPPSCompare Packed Single-Precision Floating-Point Values                                
CMPS/CMPSB/CMPSW/CMPSD/CMPSQCompare String Operands                               
CMPSDCompare Scalar Double-Precision Floating-Point Values                                 
CMPSSCompare Scalar Single-Precision Floating-Point Values                                   
CMPXCHGCompare and Exchange                                                                                         
CMPXCHG8B/CMPXCHG16BCompare and Exchange Bytes                                         
COMISDCompare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS                                                                                                
COMISSCompare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS                                                                                                
CPUIDCPU Identification                                                                                                          
CRC32  Accumulate CRC32 Value                                                                                        
CVTDQ2PDConvert Packed Dword Integers to Packed Double-Precision FP Values   
CVTDQ2PSConvert Packed Dword Integers to Packed Single-Precision FP Values   
CVTPD2DQConvert Packed Double-Precision FP Values to Packed Dword Integers   
CVTPD2PIConvert Packed Double-Precision FP Values to Packed Dword Integers    
CVTPD2PSConvert Packed Double-Precision FP Values to Packed Single-Precision FP Values                                                                                            
CVTPI2PDConvert Packed Dword Integers to Packed Double-Precision FP Values    
CVTPI2PSConvert Packed Dword Integers to Packed Single-Precision FP Values      
CVTPS2DQConvert Packed Single-Precision FP Values to Packed Dword Integers   
CVTPS2PDConvert Packed Single-Precision FP Values to Packed Double-Precision FP Values                                                                                            
CVTPS2PIConvert Packed Single-Precision FP Values to Packed Dword Integers      
CVTSD2SIConvert Scalar Double-Precision FP Value to Integer                                  
CVTSD2SSConvert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value                                                                                              
CVTSI2SDConvert Dword Integer to Scalar Double-Precision FP Value                  
CVTSI2SSConvert Dword Integer to Scalar Single-Precision FP Value                      
CVTSS2SDConvert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value                                                                                              
CVTSS2SIConvert Scalar Single-Precision FP Value to Dword Integer                      
CVTTPD2DQConvert with Truncation Packed Double-Precision FP Values to Packed Dword Integers                                                                                       
CVTTPD2PIConvert with Truncation Packed Double-Precision FP Values to Packed Dword Integers                                                                                       
CVTTPS2DQConvert with Truncation Packed Single-Precision FP Values to Packed Dword Integers                                                                                       
CVTTPS2PIConvert with Truncation Packed Single-Precision FP Values to Packed Dword Integers                                                                                       
CVTTSD2SIConvert with Truncation Scalar Double-Precision FP Value to Signed Integer                                                                                               
CVTTSS2SIConvert with Truncation Scalar Single-Precision FP Value to Dword Integer
CWD/CDQ/CQOConvert Word to Doubleword/Convert Doubleword to Quadword
DAADecimal Adjust AL after Addition                                                                                  
DASDecimal Adjust AL after Subtraction                                                                            
DECDecrement by 1                                                                                                                  
DIVUnsigned Divide                                                                                                                   
DIVPDDivide Packed Double-Precision Floating-Point Values                                      
DIVPSDivide Packed Single-Precision Floating-Point Values                                         
DIVSDDivide Scalar Double-Precision Floating-Point Values                                        
DIVSSDivide Scalar Single-Precision Floating-Point Values                                          
DPPD  Dot Product of Packed Double Precision Floating-Point Values                   
DPPS  Dot Product of Packed Single Precision Floating-Point Values                       
EMMSEmpty MMX Technology State                                                                                  
ENTERMake Stack Frame for Procedure Parameters                                                    
EXTRACTPS  Extract Packed Single Precision Floating-Point Value                           
F2XM1Compute 2xC1                                                                                                               
FABSAbsolute Value                                                                                                               
FADD/FADDP/FIADDAdd                                                                                                       
FBLDLoad Binary Coded Decimal                                                                                          
FBSTPStore BCD Integer and Pop                                                                                         
FCHSChange Sign                                                                                                                       
FCLEX/FNCLEXClear Exceptions                                                                                            
FCMOVccFloating-Point Conditional Move                                                                         
FCOMI/FCOMIP/ FUCOMI/FUCOMIPCompare Floating Point Values and Set EFLAGS
FCOSCosine                                                                                                                                  
FDECSTPDecrement Stack-Top Pointer                                                                               
FDIV/FDIVP/FIDIVDivide                                                                                                           
FDIVR/FDIVRP/FIDIVRReverse Divide                                                                                
FFREEFree Floating-Point Register                                                                                      
FICOM/FICOMPCompare Integer                                                                                            
FILDLoad Integer                                                                                                                       
FINCSTPIncrement Stack-Top Pointer                                                                                 
FINIT/FNINITInitialize Floating-Point Unit                                                                           
FIST/FISTPStore Integer                                                                                                          
FISTTPStore Integer with Truncation                                                                                  
FLDLoad Floating Point Value                                                                                                
FLD1/FLDL2T/FLDL2E/FLDPI/FLDLG2/FLDLN2/FLDZLoad Constant                        
FLDCWLoad x87 FPU Control Word                                                                                      
FLDENVLoad x87 FPU Environment                                                                                  
FMUL/FMULP/FIMULMultiply                                                                                                 
FNOPNo Operation                                                                                                                   
FPATANPartial Arctangent                                                                                                     
FPREMPartial Remainder                                                                                                        
FPREM1Partial Remainder                                                                                                    
FPTANPartial Tangent                                                                                                              
FRNDINTRound to Integer                                                                                                      
FRSTORRestore x87 FPU State                                                                                        
FSAVE/FNSAVEStore x87 FPU State                                                                                
FSCALEScale                                                                                                                               
FSINSine                                                                                                                                        
FSINCOSSine and Cosine                                                                                                          
FSQRTSquare Root                                                                                                                    
FST/FSTPStore Floating Point Value                                                                                   
FSTCW/FNSTCWStore x87 FPU Control Word                                                                 
FSTENV/FNSTENVStore x87 FPU Environment                                                              
FSTSW/FNSTSWStore x87 FPU Status Word                                                                    
FSUB/FSUBP/FISUBSubtract                                                                                                 
FSUBR/FSUBRP/FISUBRReverse Subtract                                                                        
FTSTTEST                                                                                                                                     
FUCOM/FUCOMP/FUCOMPPUnordered Compare Floating Point Values                  
FXAMExamine ModR/M                                                                                                           
FXCHExchange Register Contents                                                                                       
FXRSTORRestore x87 FPU, MMX , XMM, and MXCSR State                                        
FXSAVESave x87 FPU, MMX Technology, and SSE State                                              
FXTRACTExtract Exponent and Significand                                                                      
FYL2XCompute y * log2x                                                                                                       
FYL2XP1Compute y * log2(x +1)                                                                                          
HADDPDPacked Double-FP Horizontal Add                                                                       
HADDPSPacked Single-FP Horizontal Add                                                                          
HLTHalt                                                                                                                                         
HSUBPDPacked Double-FP Horizontal Subtract                                                               
HSUBPSPacked Single-FP Horizontal Subtract                                                                 
IDIVSigned Divide                                                                                                                      
IMULSigned Multiply                                                                                                                  
INInput from Port                                                                                                                        
INCIncrement by 1                                                                                                                     
INS/INSB/INSW/INSDInput from Port to String                                                                
INSERTPS  Insert Packed Single Precision Floating-Point Value                               
INT n/INTO/INT 3Call to Interrupt Procedure                                                                   
INVDInvalidate Internal Caches                                                                                             
INVLPGInvalidate TLB Entry                                                                                                 
IRET/IRETDInterrupt Return                                                                                                  
JccJump if Condition Is Met                                                                                                       
JMPJump                                                                                                                                        
LAHFLoad Status Flags into AH Register                                                                           
LARLoad Access Rights Byte                                                                                                  
LDDQULoad Unaligned Integer 128 Bits                                                                            
LDMXCSRLoad MXCSR Register                                                                                            
LDS/LES/LFS/LGS/LSSLoad Far Pointer                                                                               
LEALoad Effective Address                                                                                                     
LEAVEHigh Level Procedure Exit                                                                                           
LFENCELoad Fence                                                                                                                    
LGDT/LIDTLoad Global/Interrupt Descriptor Table Register                                         
LLDTLoad Local Descriptor Table Register                                                                         
LMSWLoad Machine Status Word                                                                                          
LOCKAssert LOCK# Signal Prefix                                                                                           
LODS/LODSB/LODSW/LODSD/LODSQLoad String                                                            
LOOP/LOOPccLoop According to ECX Counter                                                                  
LSLLoad Segment Limit                                                                                                            
LTRLoad Task Register                                                                                                             
MASKMOVDQUStore Selected Bytes of Double Quadword                                           
MASKMOVQStore Selected Bytes of Quadword                                                                   
MAXPDReturn Maximum Packed Double Precision Floating Point Values                   
MAXPSReturn Maximum Packed Single Precision Floating Point Values                     
MAXSDReturn Maximum Scalar Double Precision Floating Point Value                       
MAXSSReturn Maximum Scalar Single Precision Floating Point Value                        
MFENCEMemory Fence                                                                                                                
MINPDReturn Minimum Packed Double Precision Floating Point Values                      
MINPSReturn Minimum Packed Single Precision Floating Point Values                        
MINSDReturn Minimum Scalar Double Precision Floating Point Value                        
MINSSReturn Minimum Scalar Single Precision Floating Point Value                         
MONITORSet Up Monitor Address                                                                                        
MOVMove                                                                                                                                    
MOVMove to/from Control Registers                                                                                   
MOVMove to/from Debug Registers                                                                                     
MOVAPDMove Aligned Packed Double-Precision Floating-Point Values                  
MOVAPSMove Aligned Packed Single-Precision Floating-Point Values                     
MOVBEMove Data After Swapping Bytes                                                                          
MOVD/MOVQMove Doubleword/Move Quadword                                                          
MOVDDUPMove One Double-FP and Duplicate                                                               
MOVDQAMove Aligned Double Quadword                                                                         
MOVDQUMove Unaligned Double Quadword                                                                  
MOVDQ2QMove Quadword from XMM to MMX Technology Register                      
MOVHLPS Move Packed Single-Precision Floating-Point Values High to Low       
MOVHPDMove High Packed Double-Precision Floating-Point Value                         
MOVHPSMove High Packed Single-Precision Floating-Point Values                          
MOVLHPSMove Packed Single-Precision Floating-Point Values Low to High         
MOVLPDMove Low Packed Double-Precision Floating-Point Value                            
MOVLPSMove Low Packed Single-Precision Floating-Point Values                           
MOVMSKPDExtract Packed Double-Precision Floating-Point Sign Mask                 
MOVMSKPSExtract Packed Single-Precision Floating-Point Sign Mask                    
MOVNTDQA  Load Double Quadword Non-Temporal Aligned Hint                            
MOVNTDQStore Double Quadword Using Non-Temporal Hint                                  
MOVNTIStore Doubleword Using Non-Temporal Hint                                                   
MOVNTPDStore Packed Double-Precision Floating-Point Values Using Non-Temporal Hint                                                                                                
MOVNTPSStore Packed Single-Precision Floating-Point Values Using Non-Temporal Hint                                                                                                
MOVNTQStore of Quadword Using Non-Temporal Hint                                                
MOVQMove Quadword                                                                                                         
MOVQ2DQMove Quadword from MMX Technology to XMM Register                     
MOVS/MOVSB/MOVSW/MOVSD/MOVSQMove Data from String to String             
MOVSDMove Scalar Double-Precision Floating-Point Value                                         
MOVSHDUPMove Packed Single-FP High and Duplicate                                              
MOVSLDUPMove Packed Single-FP Low and Duplicate                                                 
MOVSSMove Scalar Single-Precision Floating-Point Values                                         
MOVSX/MOVSXDMove with Sign-Extension                                                                    
MOVUPDMove Unaligned Packed Double-Precision Floating-Point Values            
MOVUPSMove Unaligned Packed Single-Precision Floating-Point Values              
MOVZXMove with Zero-Extend                                                                                            
MPSADBW  Compute Multiple Packed Sums of Absolute Difference                       
MULUnsigned Multiply                                                                                                             
MULPDMultiply Packed Double-Precision Floating-Point Values                                
MULPSMultiply Packed Single-Precision Floating-Point Values                                   
MULSDMultiply Scalar Double-Precision Floating-Point Values                                    
MULSSMultiply Scalar Single-Precision Floating-Point Values                                      
MWAITMonitor Wait                                                                                                                                                                 
NEGTwo's Complement Negation                                                                                              
NOPNo Operation                                                                                                                          
NOTOne's Complement Negation                                                                                           
ORLogical Inclusive OR                                                                                                             
ORPDBitwise Logical OR of Double-Precision Floating-Point Values                           
ORPSBitwise Logical OR of Single-Precision Floating-Point Values                           
OUTOutput to Port                                                                                                                      
OUTS/OUTSB/OUTSW/OUTSDOutput String to Port                                                         
PABSB/PABSW/PABSD  Packed Absolute Value                                                               
PACKSSWB/PACKSSDWPack with Signed Saturation                                                       
PACKUSDW  Pack with Unsigned Saturation                                                                        
PACKUSWBPack with Unsigned Saturation                                                                      
PADDB/PADDW/PADDDAdd Packed Integers                                                                     
PADDQAdd Packed Quadword Integers                                                                               
PADDSB/PADDSWAdd Packed Signed Integers with Signed Saturation                    
PADDUSB/PADDUSWAdd Packed Unsigned Integers with Unsigned Saturation    
PALIGNR  Packed Align Right                                                                                                   
PANDLogical AND                                                                                                                          
PANDNLogical AND NOT                                                                                                             
PAUSESpin Loop Hint                                                                                                               
PAVGB/PAVGWAverage Packed Integers                                                                         
PBLENDVB  Variable Blend Packed Bytes                                                                         
PBLENDW  Blend Packed Words                                                                                              
PCMPEQB/PCMPEQW/PCMPEQD Compare Packed Data for Equal                                
PCMPEQQ  Compare Packed Qword Data for Equal                                                           
PCMPESTRI  Packed Compare Explicit Length Strings, Return Index                           
PCMPESTRM  Packed Compare Explicit Length Strings, Return Mask                         
PCMPGTB/PCMPGTW/PCMPGTDCompare Packed Signed Integers for Greater Than 
PCMPGTQ  Compare Packed Data for Greater Than                                                      
PCMPISTRI  Packed Compare Implicit Length Strings, Return Index                        
PCMPISTRM  Packed Compare Implicit Length Strings, Return Mask                         
PEXTRB/PEXTRD/PEXTRQ  Extract Byte/Dword/Qword                                             
PEXTRWExtract Word                                                                                                             
PHADDW/PHADDD  Packed Horizontal Add                                                                      
PHADDSW  Packed Horizontal Add and Saturate                                                            
PHMINPOSUW  Packed Horizontal Word Minimum                                                          
PHSUBW/PHSUBD  Packed Horizontal Subtract                                                              
PHSUBSW  Packed Horizontal Subtract and Saturate                                                    
PINSRB/PINSRD/PINSRQ  Insert Byte/Dword/Qword                                                     
PINSRWInsert Word                                                                                                                  
PMADDUBSW  Multiply and Add Packed Signed and Unsigned Bytes                       
PMADDWDMultiply and Add Packed Integers                                                                  
PMAXSB  Maximum of Packed Signed Byte Integers                                                     
PMAXSD  Maximum of Packed Signed Dword Integers                                                  
PMAXSWMaximum of Packed Signed Word Integers                                                    
PMAXUBMaximum of Packed Unsigned Byte Integers                                                 
PMAXUD  Maximum of Packed Unsigned Dword Integers                                          
PMAXUW  Maximum of Packed Word Integers                                                                 
PMINSB  Minimum of Packed Signed Byte Integers                                                        
PMINSD  Minimum of Packed Dword Integers                                                                  
PMINSWMinimum of Packed Signed Word Integers                                                       
PMINUBMinimum of Packed Unsigned Byte Integers                                                    
PMINUD  Minimum of Packed Dword Integers                                                                 
PMINUW  Minimum of Packed Word Integers                                                                   
PMOVMSKBMove Byte Mask                                                                                                 
PMOVSX  Packed Move with Sign Extend                                                                          
PMOVZX  Packed Move with Zero Extend                                                                         
PMULDQ  Multiply Packed Signed Dword Integers                                                         
PMULHRSW  Packed Multiply High with Round and Scale                                        
PMULHUWMultiply Packed Unsigned Integers and Store High Result                      
PMULHWMultiply Packed Signed Integers and Store High Result                           
PMULLD  Multiply Packed Signed Dword Integers and Store Low Result               
PMULLWMultiply Packed Signed Integers and Store Low Result                               
PMULUDQMultiply Packed Unsigned Doubleword Integers                                        
POPPop a Value from the Stack                                                                                        
POPA/POPADPop All General-Purpose Registers                                                            
POPCNT  Return the Count of Number of Bits Set to 1                                               
POPF/POPFD/POPFQPop Stack into EFLAGS Register                                                   
PORBitwise Logical OR                                                                                                            
PREFETCHhPrefetch Data Into Caches                                                                                
PSADBWCompute Sum of Absolute Differences                                                              
PSHUFB  Packed Shuffle Bytes                                                                                         
PSHUFDShuffle Packed Doublewords                                                                                  
PSHUFHWShuffle Packed High Words                                                                                
PSHUFLWShuffle Packed Low Words                                                                               
PSHUFWShuffle Packed Words                                                                                             
PSIGNB/PSIGNW/PSIGND  Packed SIGN                                                                              
PSLLDQShift Double Quadword Left Logical                                                                     
PSLLW/PSLLD/PSLLQShift Packed Data Left Logical                                                      
PSRAW/PSRADShift Packed Data Right Arithmetic                                                        
PSRLDQShift Double Quadword Right Logical                                                                 
PSRLW/PSRLD/PSRLQShift Packed Data Right Logical                                                  
PSUBB/PSUBW/PSUBDSubtract Packed Integers                                                          
PSUBQSubtract Packed Quadword Integers                                                                
PSUBSB/PSUBSWSubtract Packed Signed Integers with Signed Saturation           
PSUBUSB/PSUBUSWSubtract Packed Unsigned Integers with Unsigned Saturation 
PTEST- Logical Compare                                                                                                             
PUNPCKHBW/PUNPCKHWD/PUNPCKHDQ/PUNPCKHQDQ Unpack High Data        
PUNPCKLBW/PUNPCKLWD/PUNPCKLDQ/PUNPCKLQDQ Unpack Low Data                                                                                                              
PUSHPush Word, Doubleword or Quadword Onto the Stack                                      
PUSHA/PUSHADPush All General-Purpose Registers                                                    
PUSHF/PUSHFDPush EFLAGS Register onto the Stack                                                
PXORLogical Exclusive OR                                                                                                     
RCL/RCR/ROL/ROR-Rotate                                                                                                      
RCPPSCompute Reciprocals of Packed Single-Precision Floating-Point Values     
RCPSSCompute Reciprocal of Scalar Single-Precision Floating-Point Values        
RDMSRRead from Model Specific Register                                                                       
RDPMCRead Performance-Monitoring Counters                                                               
RDTSCRead Time-Stamp Counter                                                                                         
RDTSCPRead Time-Stamp Counter and Processor ID                                                    
REP/REPE/REPZ/REPNE/REPNZRepeat String Operation Prefix                               
RETReturn from Procedure                                                                                                     
ROUNDPD  Round Packed Double Precision Floating-Point Values                           
ROUNDPS  Round Packed Single Precision Floating-Point Values                             
ROUNDSD  Round Scalar Double Precision Floating-Point Values                              
ROUNDSS  Round Scalar Single Precision Floating-Point Values                                
RSMResume from System Management Mode                                                                 
RSQRTPSCompute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values                                                                                       
RSQRTSSCompute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value                                                                                          
SAHFStore AH into Flags                                                                                                        
SAL/SAR/SHL/SHRShift                                                                                                           
SBBInteger Subtraction with Borrow                                                                                 
SCAS/SCASB/SCASW/SCASDScan String                                                                             
SETccSet Byte on Condition                                                                                                
SFENCEStore Fence                                                                                                                  
SGDTStore Global Descriptor Table Register                                                                     
SHLDDouble Precision Shift Left                                                                                        
SHRDDouble Precision Shift Right                                                                                        
SHUFPDShuffle Packed Double-Precision Floating-Point Values                             
SHUFPSShuffle Packed Single-Precision Floating-Point Values                                 
SIDTStore Interrupt Descriptor Table Register                                                                
SLDTStore Local Descriptor Table Register                                                                     
SMSWStore Machine Status Word                                                                                       
SQRTPSCompute Square Roots of Packed Single-Precision Floating-Point Values    
SQRTSDCompute Square Root of Scalar Double-Precision Floating-Point Value  4-450
SQRTSSCompute Square Root of Scalar Single-Precision Floating-Point Value    4-453
STCSet Carry Flag                                                                                                                     
STDSet Direction Flag                                                                                                              
STISet Interrupt Flag                                                                                                               
STMXCSRStore MXCSR Register State                                                                         
STOS/STOSB/STOSW/STOSD/STOSQStore String                                                     
STRStore Task Register                                                                                                        
SUBSubtract                                                                                                                            
SUBPDSubtract Packed Double-Precision Floating-Point Values                           
SUBPSSubtract Packed Single-Precision Floating-Point Values                         
SUBSDSubtract Scalar Double-Precision Floating-Point Values                            
SUBSSSubtract Scalar Single-Precision Floating-Point Values                                 
SWAPGSSwap GS Base Register                                                                                           
SYSCALLFast System Call                                                                                                       
SYSENTERFast System Call                                                                                                     
SYSEXITFast Return from Fast System Call                                                                 
SYSRETReturn From Fast System Call                                                                         
TESTLogical Compare                                                                                                          
UCOMISDUnordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS                                                                                             
UCOMISSUnordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS                                                                                             
UD2Undefined Instruction                                                                                                 
UNPCKHPDUnpack and Interleave High Packed Double-Precision Floating-Point Values
UNPCKHPSUnpack and Interleave High Packed Single-Precision Floating-Point Values
UNPCKLPDUnpack and Interleave Low Packed Double-Precision Floating-Point Values
UNPCKLPSUnpack and Interleave Low Packed Single-Precision Floating-Point Values
VERR/VERWVerify a Segment for Reading or Writing                                                   
WAIT/FWAITWait                                                                                                                   
WBINVDWrite Back and Invalidate Cache                                                                            
WRMSRWrite to Model Specific Register                                                                         
XADDExchange and Add                                                                                                    
XCHGExchange Register/Memory with Register                                                             
XGETBVGet Value of Extended Control Register                                                            
XLAT/XLATBTable Look-up Translation                                                                           
XORLogical Exclusive OR                                                                                                         
XORPDBitwise Logical XOR for Double-Precision Floating-Point Values                  
XORPSBitwise Logical XOR for Single-Precision Floating-Point Values                
XRSTORRestore Processor Extended States                                                                   
XSAVESave Processor Extended States                                                                          
XSETBVSet Extended Control Register                                                                            

8088ָ	
 
һݴָ 
ָ 
߼ָ 
ġָ 
塢תָ 
αָ 

һݴָ 
 
ڴͼĴĴ˿֮䴫. 
1. ͨݴָ. 
MOV ֻֽ. 
MOVSX ȷչ,ٴ. 
MOVZX չ,ٴ. 
PUSHѹջ. 
POP ֵջ. 
PUSHA AX,CX,DX,BX,SP,BP,SI,DIѹջ. 
POPADI,SI,BP,SP,BX,DX,CX,AXεջ. 
PUSHADEAX,ECX,EDX,EBX,ESP,EBP,ESI,EDIѹջ. 
POPAD EDI,ESI,EBP,ESP,EBX,EDX,ECX,EAXεջ. 
BSWAP 32λĴֽڵ˳ 
XCHGֻֽ.( һΪĴ,μĴΪ) 
CMPXCHG Ƚϲ.( ڶΪۼAL/AX/EAX ) 
XADDȽۼ.( ڵһ ) 
XLATֽڲת. 
 BX ָһ 256 ֽڵı, AL Ϊֵ (0-255, 
0-FFH);  AL Ϊ. ( [BX+AL]->AL ) 

2. ˿ڴָ. 
INI/O˿. ( ﷨: IN ۼ, ) 
OUT I/O˿. ( ﷨: OUT ,ۼ ) 
˿ʽָʱ, ䷶Χ 0-255; ɼĴ DX ָʱ, ䷶Χ 0-65535. 
 
3. Ŀĵַָ. 
LEAװЧַ. 
: LEA DX,string;ƫƵַ浽DX. 
 
LDSĿָ,ָװDS. 
: LDS SI,string;Ѷεַ:ƫƵַ浽DS:SI. 
 
LESĿָ,ָװES. 
: LES DI,string;Ѷεַ:ƫƵַ浽ES:DI. 
 
LFSĿָ,ָװFS. 
: LFS DI,string;Ѷεַ:ƫƵַ浽FS:DI. 
 
LGSĿָ,ָװGS. 
: LGS DI,string;Ѷεַ:ƫƵַ浽GS:DI. 
 
LSSĿָ,ָװSS. 
: LSS DI,string;Ѷεַ:ƫƵַ浽SS:DI. 
 
4. ־ָ. 
LAHF־Ĵ,ѱ־װAH. 
SAHF־Ĵ,AHװ־Ĵ. 
PUSHF ־ջ. 
POPF־ջ. 
PUSHD 32λ־ջ. 
POPD32λ־ջ. 

ָ 
 
ADD ӷ. 
ADC λӷ. 
INC  1. 
AAA ӷASCII. 
DAA ӷʮƵ. 
SUB . 
SBB λ. 
DEC  1. 
NEC ( 0 ֮). 
CMP Ƚ.(,޸ı־λ,ͽ). 
AAS ASCII. 
DAS ʮƵ. 
MUL ޷ų˷. 
IMUL˷. 
,AHAL(ֽ),DXAX(). 
 
AAM ˷ASCII. 
DIV ޷ų. 
IDIV. 
,: 
̻AL,AH, (ֽ); ̻AX,DX, (). 
 
AAD ASCII. 
CBW ֽתΪ. (ALֽڵķչAHȥ) 
CWD תΪ˫. (AXеֵķչDXȥ) 
CWDEתΪ˫. (AXеַչEAXȥ) 
CDQ ˫չ. (EAXеֵķչEDXȥ) 

߼ָ 
 
AND. 
OR . 
XOR. 
NOTȡ. 
TEST .(,޸ı־λ,ͽ). 
SHL߼. 
SAL.(=SHL) 
SHR߼. 
SAR.(=SHR) 
ROLѭ. 
RORѭ. 
RCLͨλѭ. 
RCRͨλѭ. 
ϰλָ,λɴ255. 
λһʱ, ֱò. SHL AX,1. 
λ>1ʱ, ɼĴCLλ. 
硡MOV CL,04 
SHL AX,CL 

ġָ 
 
DS:SI ԴμĴ:Դַ. 
ES:DI Ŀ괮μĴ:Ŀ괮ַ. 
CXظ. 
 
AL/AX ɨֵ. 
D־ 0ʾظSIDIӦԶ; 1ʾӦԶ. 
Z־ ɨȽϲĽ. 
 
MOVS. 
( MOVSBַ. MOVSW.MOVSD˫. ) 
 
CMPSȽ. 
( CMPSBȽַ. CMPSWȽ. ) 
 
SCASɨ. 
ALAXĿ괮Ƚ,ȽϽӳڱ־λ. 
 
LODSװ봮. 
ԴеԪ(ֻֽ)һװALAX. 
( LODSBַ.LODSW.LODSD˫. ) 
 
STOS洮. 
LODS. 
 
REP CX/ECX<>0ʱظ. 
REPE/REPZ ZF=1ȽϽ,CX/ECX<>0ʱظ. 
REPNE/REPNZ ZF=0ȽϽ,CX/ECX<>0ʱظ. 
REPCCF=1CX/ECX<>0ʱظ. 
REPNC CF=0CX/ECX<>0ʱظ. 

塢תָ 
 
1>תָ (ת) 
JMP תָ 
CALL̵ 
RET/RETF̷. 
 
2>תָ (ת,-128+127ľ) 
 ( ҽ(SF XOR OF)=1ʱ,OP1 
JA/JNBE Сڻ򲻵ʱת. 
JAE/JNB ڻת. 
JB/JNAE Сת. 
JBE/JNA Сڻת. 
,޷Ľ(־CZ). 
 
JG/JNLE ת. 
JGE/JNL ڻת. 
JL/JNGE Сת. 
JLE/JNG Сڻת. 
,ԴĽ(־S,OZ). 
 
JE/JZ ת. 
JNE/JNZ ʱת. 
JCнλʱת. 
JNC ޽λʱת. 
JNO ʱת. 
JNP/JPO żΪʱת. 
JNS λΪ "0" ʱת. 
JOת. 
JP/JPEżΪżʱת. 
JSλΪ "1" ʱת. 
 
3>ѭָ(ת) 
LOOPCXΪʱѭ. 
LOOPE/LOOPZ CXΪұ־Z=1ʱѭ. 
LOOPNE/LOOPNZ CXΪұ־Z=0ʱѭ. 
JCXZCXΪʱת. 
JECXZ ECXΪʱת. 
 
4>жָ 
INT жָ 
INTOж 
IRETжϷ 
 
5>ָ 
HLT ͣ, ֱжϻλźŲż. 
WAITоƬTESTΪߵƽʱʹCPUȴ״̬. 
ESC ת⴦. 
LOCK. 
NOP ղ. 
STC ýλ־λ. 
CLC λ־λ. 
CMC λ־ȡ. 
STD ÷־λ. 
CLD 巽־λ. 
STI жλ. 
CLI жλ. 

αָ 
 
DW(2ֽ). 
PROC. 
ENDP̽. 
SEGMENT . 
ASSUMEμĴѰַ. 
ENDSν. 
END .