MOVDQA
Usage: MOVDQA dest,src Modifies flags: None
Moves a double quadword from the 'src' (second operand) to the 'dest' (first operand). This instruction can be used to load an XMM register from a 128-bit memory location, to store the contents of an XMM register into a 128-bit memory location, or to move data between two XMM registers.
Move Aligned Double Quadword
MOVDQA xmm1,xmm2/m128 ; 66 OF 6F /r [WILLAMETTE,SSE2]
MOVDQA xmm1/m128,xmm2 ; 66 OF 7F /r [WILLAMETTE,SSE2]
MOVDQA moves a double quadword from the source operand to the destination operand. When the source or destination operand is a memory location, it must be aligned to a 16-byte boundary.
When the 'src' or 'dest' operand is a memory operand, it must be aligned on a 16-byte boundary or a general-protection exception (#GP) will be generated.
To move a double quadword to or from unaligned memory locations, use the MOVDQU instruction.
EXAMPLE:
movdqa xmm1 Label
MOVDQ2Q
Usage: MOVDQ2Q dest,src Modifies flags: None
Moves the low quadword from the 'src' operand to the 'dest'.
Move Quadword from XMM to MMX register.
MOVDQ2Q mm,xmm ; F2 OF D6 /r [WILLAMETTE,SSE2]
MOVDQ2Q moves the low quadword from the source operand to the destination operand.
The 'src' operand is an XMM register and the 'dest' operand is an MMX technology register.
EXAMPLE:
movdq2q mmx 2 xmm1
MOVDDUP
Usage: MOVDDUP dest,src Modifies flags: None
Move 64 bits representing the lower DP data element from 'src' to 'dest'.
Move One Double-FP and Duplicate
MOVDDUP xmm1, xmm2/mem64 ; F2 0F 12 /r [Pent4]
The linear address corresponds to the address of the least-significant byte of the referenced memory data. When a memory address is indicated, the 8 bytes of data at memory location mem64 are loaded. When the register-register form of this operation is used, the lower half of the 128- bit source register is duplicated and copied into the 128-bit destination register.
If source = mem64 load instruction
xmm1[63-0] = mem64;
xmm1[127-64] = mem64
Or
move instruction
xmm1[63-0] = xmm2[63-0];
xmm1[127-64] = xmm2[63-0]
EXAMPLE:
movddup xmm1 xmm2
MOVD
Usage: MOVD dest,src Modifies flags: None
Copies a doubleword from the 'src' to the 'dest' The 'src' and 'dest' operands can be general-purpose registers, MMX technology registers, XMM registers, or 32-bit memory locations.
Move Doubleword to/from MMX Register
MOVD mm,r/m32 ; 0F 6E /r [PENT,MMX]
MOVD r/m32,mm ; 0F 7E /r [PENT,MMX]
MOVD xmm,r/m32 ; 66 0F 6E /r [WILLAMETTE,SSE2]
MOVD r/m32,xmm ; 66 0F 7E /r [WILLAMETTE,SSE2]
MOVD copies 32 bits from its source (second) operand into its destination (first) operand. When the destination is a 64-bit MMX register or a 128-bit XMM register, the input value is zero-extended to fill the destination register.
This instruction can be used to move a doubleword to and from the low doubleword of an MMX technology register and a general-purpose register or a 32-bit memory location, or to and from the low doubleword of an XMM register and a general-purpose register or a 32-bit memory location. The instruction cannot be used to transfer data between MMX technology registers, between XMM registers, between general-purpose registers, or between memory.
EXAMPLE:
movd xmm1 Label
MOVAPS
Usage: MOVAPS dest,src Modifies flags: None
Moves a double quadword containing four packed single-precision floating-point values from the 'src' to the 'dest'.This instruction can be used to load an XMM register from a 128-bit memory location, to store the contents of an XMM register into a 128-bit memory location, or to move data between two XMM registers. Move Aligned Packed Single-Precision FP Values
MOVAPS xmm1,xmm2/mem128 ; 0F 28 /r [KATMAI,SSE]
MOVAPS xmm1/mem128,xmm2 ; 0F 29 /r [KATMAI,SSE]
MOVAPS moves a double quadword containing 4 packed single-precision FP values from the source operand to the destination. When the 'src' or 'dest' operand is a memory operand, the operand must be aligned on a 16-byte boundary or a general-protection exception (#GP) is generated.
To move data in and out of memory locations that are not known to be on 16-byte boundaries, use the MOVUPS instruction.
EXAMPLE:
movaps xmm1 Label
MOVAPD
Usage: MOVAPD dest,src Modifies flags: None
Moves a double quadword containing two packed double-precision floating-point values from the 'src' (second operand) to the 'dest' (first operand).
Move Aligned Packed Double-Precision FP Values
MOVAPD xmm1,xmm2/mem128 ; 66 0F 28 /r [WILLAMETTE,SSE2]
MOVAPD xmm1/mem128,xmm2 ; 66 0F 29 /r [WILLAMETTE,SSE2]
MOVAPD moves a double quadword containing 2 packed double-precision FP values from the source operand to the destination. When the source or destination operand is a memory location, it must be aligned on a 16-byte boundary or a general-protection exception (#GP) will be generated.
To move data in and out of memory locations that are not known to be on 16-byte boundaries, use the MOVUPD instruction.
EXAMPLE:
movapd xmm1 Label
MOV
Usage: MOV dest,src Modifies flags: None
Copies byte, word or doubleword from the source operand to the destination operand.
Move Data
MOV r/m8,reg8 ; 88 /r [8086]
MOV r/m16,reg16 ; o16 89 /r [8086]
MOV r/m32,reg32 ; o32 89 /r [386]
MOV reg8,r/m8 ; 8A /r [8086]
MOV reg16,r/m16 ; o16 8B /r [8086]
MOV reg32,r/m32 ; o32 8B /r [386]
MOV reg8,imm8 ; B0+r ib [8086]
MOV reg16,imm16 ; o16 B8+r iw [8086]
MOV reg32,imm32 ; o32 B8+r id [386]
MOV r/m8,imm8 ; C6 /0 ib [8086]
MOV r/m16,imm16 ; o16 C7 /0 iw [8086]
MOV r/m32,imm32 ; o32 C7 /0 id [386]
MOV AL,memoffs8 ; A0 ow/od [8086]
MOV AX,memoffs16 ; o16 A1 ow/od [8086]
MOV EAX,memoffs32 ; o32 A1 ow/od [386]
MOV memoffs8,AL ; A2 ow/od [8086]
MOV memoffs16,AX ; o16 A3 ow/od [8086]
MOV memoffs32,EAX ; o32 A3 ow/od [386]
MOV r/m16,segreg ; o16 8C /r [8086]
MOV r/m32,segreg ; o32 8C /r [386]
MOV segreg,r/m16 ; o16 8E /r [8086]
MOV segreg,r/m32 ; o32 8E /r [386]
MOV reg32,CR0/2/3/4 ; 0F 20 /r [386]
MOV reg32,DR0/1/2/3/6/7 ; 0F 21 /r [386]
MOV reg32,TR3/4/5/6/7 ; 0F 24 /r [386]
MOV CR0/2/3/4,reg32 ; 0F 22 /r [386]
MOV DR0/1/2/3/6/7,reg32 ; 0F 23 /r [386]
MOV TR3/4/5/6/7,reg32 ; 0F 26 /r [386]
MOV copies the contents of its source (second) operand into its destination (first) operand.
In all forms of the MOV instruction, the two operands are the same size, except for moving between a segment register and an r/m32 operand. These instructions are treated exactly like the corresponding 16-bit equivalent (so that, for example, MOV DS,EAX functions identically to MOV DS,AX but saves a prefix when in 32-bit mode), except that when a segment register is moved into a 32-bit destination, the top two bytes of the result are undefined.
MOV may not use CS as a destination.
CR4 is only a supported register on the Pentium and above.
Test registers are supported on 386/486 processors and on some non-Intel Pentium class processors.
Examples:
[Data: 20]
mov ebx 1 ; ebx = 1
mov eax ebx ; eax = 1
mov ebx 5 ; ebx = 5
mov esi Data ; Label is Pointer to address of variable
mov eax D$esi ; eax = 20
MINSS
Usage: MINSS dest,src Modifies flags: None
Compares the low single-precision floating-point values in the 'dest' and the 'src' and returns the minimum value to the low doubleword of the 'dest' operand.
Return Scalar Single-Precision FP Minimum
MINSS xmm1,xmm2/m32 ; F3 0F 5D /r [KATMAI,SSE]
MINSS compares the low-order single-precision FP numbers from xmm1 and xmm2/mem, and stores the minimum value in xmm1. If the values being compared are both zeroes, source2 (xmm2/m32) would be returned. If source2 (xmm2/m32) is an SNaN, this SNaN is forwarded unchanged to the destination (i.e., a QNaN version of the SNaN is not returned). The high three doublewords of the destination are left unchanged.
The 'src' operand can be an XMM register or a 32-bit memory location. The 'dest' operand is an XMM register. When the 'src' operand is a memory operand, only 32 bits are accessed.
EXAMPLE:
minss xmm1 Label
MINSD
Usage: MINSD dest,src Modifies flags: None
Compares the low double-precision floating-point values in the 'dest' and the 'src' and returns the minimum value to the low quadword of the 'dest' operand. The high quadword of the 'dest' operand remains unchanged.
Return Scalar Double-Precision FP Minimum
MINSD xmm1,xmm2/m64 ; F2 0F 5D /r [WILLAMETTE,SSE2]
MINSD compares the low-order double-precision FP numbers from xmm1 and xmm2/mem, and stores the minimum value in xmm1. If the values being compared are both zeroes, source2 (xmm2/m64) would be returned. If source2 (xmm2/m64) is an SNaN, this SNaN is forwarded unchanged to the destination (i.e., a QNaN version of the SNaN is not returned). The high quadword of the destination is left unchanged.
The 'src' operand can be an XMM register or a 64-bit memory location. The 'dest' operand is an XMM register. When the 'src' operand is a memory operand, only the 64 bits are accessed.
EXAMPLE:
minsd xmm1 Label