MOVDQU, VMOVDQU8, VMOVDQU16, VMOVDQU32, VMOVDQU64

Mover los valores enteros no deseados

estableVMJITAOTinstruccion

Codificaciones

Opcode	Instruccion	Op/En	64 bits	Compat/Legacy	Descripcion
`F3 0F 6F /r`	`MOVDQU xmm1, xmm2/m128`	A	Valido	Valido	Mover los valores enteros no deseados de xmm2/m128 a xmm1.
`F3 0F 7F /r`	`MOVDQU xmm2/m128, xmm1`	B	Valido	Valido	Mover los valores enteros no deseados de xmm1 a xmm2/m128.
`VEX.128.F3.0F.WIG 6F /r`	`VMOVDQU xmm1, xmm2/m128`	A	Valido	Valido	Mover los valores enteros no deseados de xmm2/m128 a xmm1.
`VEX.128.F3.0F.WIG 7F /r`	`VMOVDQU xmm2/m128, xmm1`	B	Valido	Valido	Mover los valores enteros no deseados de xmm1 a xmm2/m128.
`VEX.256.F3.0F.WIG 6F /r`	`VMOVDQU ymm1, ymm2/m256`	A	Valido	Valido	Mover los valores enteros no deseados de ymm2/m256 a ymm1.
`VEX.256.F3.0F.WIG 7F /r`	`VMOVDQU ymm2/m256, ymm1`	B	Valido	Valido	Mover los valores enteros no deseados de ymm1 a ymm2/m256.
`EVEX.128.F2.0F.W0 6F /r`	`VMOVDQU8 xmm1 {k1}{z}, xmm2/m128`	C	Valido	Valido	Mover los valores integer de byte no deseados AVX512BW) OR AVX10.1 de xmm2/m128 a xmm1 utilizando máscara de escritura k1.
`EVEX.256.F2.0F.W0 6F /r`	`VMOVDQU8 ymm1 {k1}{z}, ymm2/m256`	C	Valido	Valido	Mover los valores integer de byte no deseados AVX512BW) OR AVX10.1 de ymm2/m256 a ymm1 utilizando máscara de escritura k1.
`EVEX.512.F2.0F.W0 6F /r`	`VMOVDQU8 zmm1 {k1}{z}, zmm2/m512`	C	Valido	Valido	Mover los valores integer de byte no deseados OR AVX10.1 de zmm2/m512 a zmm1 usando máscara de escritura k1.
`EVEX.128.F2.0F.W0 7F /r`	`VMOVDQU8 xmm2/m128 {k1}{z}, xmm1`	D	Valido	Valido	Mover los valores integer de byte no deseados AVX512BW) OR AVX10.1 de xmm1 a xmm2/m128 utilizando máscara de escritura k1.
`EVEX.256.F2.0F.W0 7F /r`	`VMOVDQU8 ymm2/m256 {k1}{z}, ymm1`	D	Valido	Valido	Mover los valores integer de byte no deseados AVX512BW) OR AVX10.1 de ymm1 a ymm2/m256 utilizando máscara de escritura k1.
`EVEX.512.F2.0F.W0 7F /r`	`VMOVDQU8 zmm2/m512 {k1}{z}, zmm1`	D	Valido	Valido	Mover los valores integer de byte no deseados OR AVX10.1 de zmm1 a zmm2/m512 usando máscara de escritura k1.
`EVEX.128.F2.0F.W1 6F /r`	`VMOVDQU16 xmm1 {k1}{z}, xmm2/m128`	C	Valido	Valido	Mover los valores de la palabra integer AVX512BW) OR AVX10.1 de xmm2/m128 a xmm1 utilizando máscara de escritura k1.
`EVEX.256.F2.0F.W1 6F /r`	`VMOVDQU16 ymm1 {k1}{z}, ymm2/m256`	C	Valido	Valido	Mover los valores de la palabra integer AVX512BW) OR AVX10.1 de ymm2/m256 a ymm1 utilizando máscara de escritura k1.
`EVEX.512.F2.0F.W1 6F /r`	`VMOVDQU16 zmm1 {k1}{z}, zmm2/m512`	C	Valido	Valido	Mover los valores de integer OR AVX10.1 de palabra sin igual de zmm2/m512 a zmm1 usando máscara de escritura k1.
`EVEX.128.F2.0F.W1 7F /r`	`VMOVDQU16 xmm2/m128 {k1}{z}, xmm1`	D	Valido	Valido	Mover los valores de la palabra integer AVX512BW) OR AVX10.1 de xmm1 a xmm2/m128 utilizando máscara de escritura k1.
`EVEX.256.F2.0F.W1 7F /r`	`VMOVDQU16 ymm2/m256 {k1}{z}, ymm1`	D	Valido	Valido	Mover los valores de la palabra integer AVX512BW) OR AVX10.1 de ymm1 a ymm2/m256 utilizando máscara de escritura k1.
`EVEX.512.F2.0F.W1 7F /r`	`VMOVDQU16 zmm2/m512 {k1}{z}, zmm1 Opcode/ Instruction`	D	Valido	Valido	Mover los valores de la palabra integer OR AVX10.1 no deseados de zmm1 a zmm2/m512 utilizando máscara de escritura k1. Op/En 64/32 bit CPUID Característica Descripción Modo Soporte Bandera Soporte Bandera
`EVEX.128.F3.0F.W0 6F /r`	`VMOVDQU32 xmm1 {k1}{z}, xmm2/mm128`	C	Valido	Valido	Mover los valores de integer de xmm2/m128 empaquetados no deseados AVX512F) OR AVX10.1 integer de xmm2/m128 a xmm1 utilizando máscara de escritura k1.
`EVEX.256.F3.0F.W0 6F /r`	`VMOVDQU32 ymm1 {k1}{z}, ymm2/m256`	C	Valido	Valido	Mover los valores de integer de ymm2/m256 empaquetados no deseados AVX512F) OR AVX10.1 integer de ymm2/m256 a ymm1 utilizando máscara de escritura k1.
`EVEX.512.F3.0F.W0 6F /r`	`VMOVDQU32 zmm1 {k1}{z}, zmm2/m512`	C	Valido	Valido	Mover los valores de integer no deseados de doblepabrado OR AVX10.1 de zmm2/m512 a zmm1 usando máscara de escritura k1.
`EVEX.128.F3.0F.W0 7F /r`	`VMOVDQU32 xmm2/m128 {k1}{z}, xmm1`	D	Valido	Valido	Mover los valores de integer de xmm1 empaquetados no deseados AVX512F) OR AVX10.1 integer de xmm1 a xmm2/m128 utilizando máscara de escritura k1.
`EVEX.256.F3.0F.W0 7F /r`	`VMOVDQU32 ymm2/m256 {k1}{z}, ymm1`	D	Valido	Valido	Mover los valores de integer de ymm1 empaquetados no deseados AVX512F) OR AVX10.1 integer de ymm1 a ymm2/m256 utilizando máscara de escritura k1.
`EVEX.512.F3.0F.W0 7F /r`	`VMOVDQU32 zmm2/m512 {k1}{z}, zmm1`	D	Valido	Valido	Mover los valores de integer no deseados de doblepabrado OR AVX10.1 de zmm1 a zmm2/m512 usando máscara de escritura k1.
`EVEX.128.F3.0F.W1 6F /r`	`VMOVDQU64 xmm1 {k1}{z}, xmm2/m128`	C	Valido	Valido	Mover los valores de quadword integer AVX512F no deseados) OR AVX10.1 de xmm2/m128 a xmm1 utilizando máscara de escritura k1.
`EVEX.256.F3.0F.W1 6F /r`	`VMOVDQU64 ymm1 {k1}{z}, ymm2/m256`	C	Valido	Valido	Mover los valores de quadword integer AVX512F no deseados) OR AVX10.1 de ymm2/m256 a ymm1 utilizando máscara de escritura k1.
`EVEX.512.F3.0F.W1 6F /r`	`VMOVDQU64 zmm1 {k1}{z}, zmm2/m512`	C	Valido	Valido	Mover los valores integer de cuádpago no deseados OR AVX10.1 de zmm2/m512 a zmm1 utilizando máscara de escritura k1.
`EVEX.128.F3.0F.W1 7F /r`	`VMOVDQU64 xmm2/m128 {k1}{z}, xmm1`	D	Valido	Valido	Mover los valores de quadword integer AVX512F no deseados) OR AVX10.1 de xmm1 a xmm2/m128 utilizando máscara de escritura k1.
`EVEX.256.F3.0F.W1 7F /r`	`VMOVDQU64 ymm2/m256 {k1}{z}, ymm1`	D	Valido	Valido	Mover los valores de quadword integer AVX512F no deseados) OR AVX10.1 de ymm1 a ymm2/m256 utilizando máscara de escritura k1.
`EVEX.512.F3.0F.W1 7F /r`	`VMOVDQU64 zmm2/m512 {k1}{z}, zmm1`	D	Valido	Valido	Mover los valores integer de cuádpago no deseados OR AVX10.1 de zmm1 a zmm2/m512 utilizando máscara de escritura k1.

Codificacion de operandos

Cada modo es un valor de la columna Op/En de arriba. Dice en que campo de la instruccion codificada va cada operando, en el orden en que se escriben, y si la instruccion lo lee, lo escribe o ambas cosas.

A

modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

B

modrm.rm escriturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide
modrm.reg lecturabyte ModRM, campo reg (bits 5-3)

C

modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

Tupla: Full Mem

D

modrm.rm escriturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide
modrm.reg lecturabyte ModRM, campo reg (bits 5-3)

Tupla: Full Mem

Coste medido

Cargando las mediciones de arch-data...

Descripción

Nota: VEX.vvvv y EVEX.vvvv están reservados y deben ser 1111b instrucciones de lo contrario #UD. EVEX versiones codificadas:

Mueva 128, 256 o 512 bits de byte/palabra/palabra/palabra doble/valor entero de cuatrimoto del operando de origen (el segundo operando) al operando de destino (primero operando). Esta instrucción se puede utilizar para cargar un registro vectorial de una ubicación de memoria, para almacenar el contenido de un registro vectorial en una ubicación de memoria, o para mover datos entre dos registros vectoriales.

El operando de destino se actualiza a 8-bit (VMOVDQU8), 16-bit (VMOVDQU16), 32-bit (VMOVDQU32), o 64-bit (VMOVDQU64) granularidad según la máscara de escritura.

VEX.256 versión codificada:

Mueva 256 bits de valores enteros empaquetados del operando de origen (segundo operando) al operando de destino (primer operando). Esta instrucción se puede utilizar para cargar un registro YMM de 256 bits ubicación de memoria, para almacenar el contenido de un registro YMM en una ubicación de memoria de 256 bits, o para mover datos entre dos registros YMM.

Bits (MAXVL-1:256) del registro de destino se ponen a cero.

128-bit versions:

Mueva 128 bits de valores enteros empaquetados del operando de origen (segundo operando) al operando de destino (primer operando). Esta instrucción se puede utilizar para cargar un registro XMM de 128 bits ubicación de memoria, para almacenar el contenido de un registro XMM en una ubicación de memoria de 128 bits, o para mover datos entre dos registros XMM.

128-bit Legacy SSE versión: Bits (MAXVL-1:128) del registro de destino correspondiente no se modifican.

Cuando la fuente o operando de destino es un operando de memoria, el operando puede no estar al tanto de cualquier alineación sin causar que una excepción de protección general (#GP) se genere

VEX.128 versión codificada: Bits (MAXVL-1:128) del registro de destino se ponen a cero.

Operación

VMOVDQU8 (EVEX Encoded Versions, Register-Copy Form)

(KL, VL) = (16, 128), (32, 256), (64, 512)

FOR j := 0 TO KL-1

i := j * 8

IF k1[j] OR *no writemask*

     THEN DEST[i+7:i] := SRC[i+7:i]

     ELSE

            IF *merging-masking*            ; merging-masking

                THEN *DEST[i+7:i] remains unchanged*

                ELSE DEST[i+7:i] := 0       ; zeroing-masking

            FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0


VMOVDQU8 (EVEX Encoded Versions, Store-Form)    ; merging-masking
(KL, VL) = (16, 128), (32, 256), (64, 512)
FOR j := 0 TO KL-1

    i := j * 8
    IF k1[j] OR *no writemask*

          THEN DEST[i+7:i] :=
                SRC[i+7:i]

          ELSE *DEST[i+7:i] remains unchanged*
    FI;
ENDFOR;

VMOVDQU8 (EVEX Encoded Versions, Load-Form)

(KL, VL) = (16, 128), (32, 256), (64, 512)

FOR j := 0 TO KL-1

i := j * 8

IF k1[j] OR *no writemask*

     THEN DEST[i+7:i] := SRC[i+7:i]

     ELSE

             IF *merging-masking*           ; merging-masking

                 THEN *DEST[i+7:i] remains unchanged*

                 ELSE DEST[i+7:i] := 0      ; zeroing-masking

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VMOVDQU16 (EVEX Encoded Versions, Register-Copy Form)

(KL, VL) = (8, 128), (16, 256), (32, 512)

FOR j := 0 TO KL-1

i := j * 16

IF k1[j] OR *no writemask*

     THEN DEST[i+15:i] := SRC[i+15:i]

     ELSE

             IF *merging-masking*           ; merging-masking

                 THEN *DEST[i+15:i] remains unchanged*

                 ELSE DEST[i+15:i] := 0     ; zeroing-masking

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VMOVDQU16 (EVEX Encoded Versions, Store-Form)

(KL, VL) = (8, 128), (16, 256), (32, 512)

FOR j := 0 TO KL-1

i := j * 16

IF k1[j] OR *no writemask*

     THEN DEST[i+15:i] :=

             SRC[i+15:i]

     ELSE *DEST[i+15:i] remains unchanged*      ; merging-masking

FI;

ENDFOR;


VMOVDQU16 (EVEX Encoded Versions, Load-Form)

(KL, VL) = (8, 128), (16, 256), (32, 512)

FOR j := 0 TO KL-1

i := j * 16

IF k1[j] OR *no writemask*

     THEN DEST[i+15:i] := SRC[i+15:i]

     ELSE

             IF *merging-masking*           ; merging-masking

                 THEN *DEST[i+15:i] remains unchanged*

                 ELSE DEST[i+15:i] := 0     ; zeroing-masking

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VMOVDQU32 (EVEX Encoded Versions, Register-Copy Form)

(KL, VL) = (4, 128), (8, 256), (16, 512)

FOR j := 0 TO KL-1

i := j * 32

IF k1[j] OR *no writemask*

     THEN DEST[i+31:i] := SRC[i+31:i]

     ELSE

             IF *merging-masking*           ; merging-masking

                 THEN *DEST[i+31:i] remains unchanged*

                 ELSE DEST[i+31:i] := 0     ; zeroing-masking

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VMOVDQU32 (EVEX Encoded Versions, Store-Form)

(KL, VL) = (4, 128), (8, 256), (16, 512)

FOR j := 0 TO KL-1

i := j * 32

IF k1[j] OR *no writemask*

     THEN DEST[i+31:i] :=

             SRC[i+31:i]

     ELSE *DEST[i+31:i] remains unchanged*     ; merging-masking

FI;

ENDFOR;

VMOVDQU32 (EVEX Encoded Versions, Load-Form)

(KL, VL) = (4, 128), (8, 256), (16, 512)

FOR j := 0 TO KL-1

i := j * 32

IF k1[j] OR *no writemask*

     THEN DEST[i+31:i] := SRC[i+31:i]

     ELSE

             IF *merging-masking*           ; merging-masking

                 THEN *DEST[i+31:i] remains unchanged*

                 ELSE DEST[i+31:i] := 0     ; zeroing-masking

             FI

FI;

ENDFOR


DEST[MAXVL-1:VL] := 0

VMOVDQU64 (EVEX Encoded Versions, Register-Copy Form)

(KL, VL) = (2, 128), (4, 256), (8, 512)

FOR j := 0 TO KL-1

i := j * 64

IF k1[j] OR *no writemask*

     THEN DEST[i+63:i] := SRC[i+63:i]

     ELSE

             IF *merging-masking*           ; merging-masking

                 THEN *DEST[i+63:i] remains unchanged*

                 ELSE DEST[i+63:i] := 0     ; zeroing-masking

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VMOVDQU64 (EVEX Encoded Versions, Store-Form)

(KL, VL) = (2, 128), (4, 256), (8, 512)

FOR j := 0 TO KL-1

i := j * 64

IF k1[j] OR *no writemask*

     THEN DEST[i+63:i] := SRC[i+63:i]

     ELSE *DEST[i+63:i] remains unchanged*     ; merging-masking

    FI;
ENDFOR;

VMOVDQU64 (EVEX Encoded Versions, Load-Form)

(KL, VL) = (2, 128), (4, 256), (8, 512)

FOR j := 0 TO KL-1

i := j * 64

IF k1[j] OR *no writemask*

     THEN DEST[i+63:i] := SRC[i+63:i]

     ELSE

             IF *merging-masking*           ; merging-masking

                 THEN *DEST[i+63:i] remains unchanged*

                 ELSE DEST[i+63:i] := 0     ; zeroing-masking

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VMOVDQU (VEX.256 Encoded Version, Load - and Register Copy)
DEST[255:0] := SRC[255:0]
DEST[MAXVL-1:256] := 0

VMOVDQU (VEX.256 Encoded Version, Store-Form)
DEST[255:0] := SRC[255:0]

VMOVDQU (VEX.128 encoded version)
DEST[127:0] := SRC[127:0]
DEST[MAXVL-1:128] := 0


VMOVDQU (128-bit Load- and Register-Copy- Form Legacy SSE Version)
DEST[127:0] := SRC[127:0]
DEST[MAXVL-1:128] (Unmodified)

(V)MOVDQU (128-bit Store-Form Version)
DEST[127:0] := SRC[127:0]

Intel C/C++ compilador intrínseco

VMOVDQU16 __m512i _mm512_mask_loadu_epi16(__m512i s, __mmask32 k, void * sa);
VMOVDQU16 __m512i _mm512_maskz_loadu_epi16( __mmask32 k, void * sa);
VMOVDQU16 void _mm512_mask_storeu_epi16(void * d, __mmask32 k, __m512i a);
VMOVDQU16 __m256i _mm256_mask_loadu_epi16(__m256i s, __mmask16 k, void * sa);
VMOVDQU16 __m256i _mm256_maskz_loadu_epi16( __mmask16 k, void * sa);
VMOVDQU16 void _mm256_mask_storeu_epi16(void * d, __mmask16 k, __m256i a);
VMOVDQU16 __m128i _mm_mask_loadu_epi16(__m128i s, __mmask8 k, void * sa);
VMOVDQU16 __m128i _mm_maskz_loadu_epi16( __mmask8 k, void * sa);
VMOVDQU16 void _mm_mask_storeu_epi16(void * d, __mmask8 k, __m128i a);
VMOVDQU32 __m512i _mm512_loadu_epi32( void * sa);
VMOVDQU32 __m512i _mm512_mask_loadu_epi32(__m512i s, __mmask16 k, void * sa);
VMOVDQU32 __m512i _mm512_maskz_loadu_epi32( __mmask16 k, void * sa);
VMOVDQU32 void _mm512_storeu_epi32(void * d, __m512i a);
VMOVDQU32 void _mm512_mask_storeu_epi32(void * d, __mmask16 k, __m512i a);
VMOVDQU32 __m256i _mm256_mask_loadu_epi32(__m256i s, __mmask8 k, void * sa);
VMOVDQU32 __m256i _mm256_maskz_loadu_epi32( __mmask8 k, void * sa);
VMOVDQU32 void _mm256_storeu_epi32(void * d, __m256i a);
VMOVDQU32 void _mm256_mask_storeu_epi32(void * d, __mmask8 k, __m256i a);
VMOVDQU32 __m128i _mm_mask_loadu_epi32(__m128i s, __mmask8 k, void * sa);
VMOVDQU32 __m128i _mm_maskz_loadu_epi32( __mmask8 k, void * sa);
VMOVDQU32 void _mm_storeu_epi32(void * d, __m128i a);
VMOVDQU32 void _mm_mask_storeu_epi32(void * d, __mmask8 k, __m128i a);
VMOVDQU64 __m512i _mm512_loadu_epi64( void * sa);
VMOVDQU64 __m512i _mm512_mask_loadu_epi64(__m512i s, __mmask8 k, void * sa);
VMOVDQU64 __m512i _mm512_maskz_loadu_epi64( __mmask8 k, void * sa);
VMOVDQU64 void _mm512_storeu_epi64(void * d, __m512i a);
VMOVDQU64 void _mm512_mask_storeu_epi64(void * d, __mmask8 k, __m512i a);
VMOVDQU64 __m256i _mm256_mask_loadu_epi64(__m256i s, __mmask8 k, void * sa);
VMOVDQU64 __m256i _mm256_maskz_loadu_epi64( __mmask8 k, void * sa);
VMOVDQU64 void _mm256_storeu_epi64(void * d, __m256i a);
VMOVDQU64 void _mm256_mask_storeu_epi64(void * d, __mmask8 k, __m256i a);
VMOVDQU64 __m128i _mm_mask_loadu_epi64(__m128i s, __mmask8 k, void * sa);
VMOVDQU64 __m128i _mm_maskz_loadu_epi64( __mmask8 k, void * sa);
VMOVDQU64 void _mm_storeu_epi64(void * d, __m128i a);
VMOVDQU64 void _mm_mask_storeu_epi64(void * d, __mmask8 k, __m128i a);
VMOVDQU8 __m512i _mm512_mask_loadu_epi8(__m512i s, __mmask64 k, void * sa);
VMOVDQU8 __m512i _mm512_maskz_loadu_epi8( __mmask64 k, void * sa);
VMOVDQU8 void _mm512_mask_storeu_epi8(void * d, __mmask64 k, __m512i a);
VMOVDQU8 __m256i _mm256_mask_loadu_epi8(__m256i s, __mmask32 k, void * sa);
VMOVDQU8 __m256i _mm256_maskz_loadu_epi8( __mmask32 k, void * sa);
VMOVDQU8 void _mm256_mask_storeu_epi8(void * d, __mmask32 k, __m256i a);
VMOVDQU8 __m128i _mm_mask_loadu_epi8(__m128i s, __mmask16 k, void * sa);
VMOVDQU8 __m128i _mm_maskz_loadu_epi8( __mmask16 k, void * sa);
VMOVDQU8 void _mm_mask_storeu_epi8(void * d, __mmask16 k, __m128i a);
MOVDQU __m256i _mm256_loadu_si256 (__m256i * p);
MOVDQU _mm256_storeu_si256(_m256i *p, __m256i a);
MOVDQU __m128i _mm_loadu_si128 (__m128i * p);
MOVDQU _mm_storeu_si128(__m128i *p, __m128i a);

SIMD coma flotante Excepciones

None.

Otras excepciones

Instrucciones no codificadas por EVEX, ver Tabla 2-21, "Tipo 4 Condiciones de Excepción de Clase".

Instrucciones de código EVEX, ver Excepciones Tipo E4.nb en la tabla 2-51, "Tipo E4 Clase Condiciones de Excepción".

Additionally:

#UD               If EVEX.vvvv != 1111B or VEX.vvvv != 1111B.

MOVDQU, VMOVDQU8, VMOVDQU16, VMOVDQU32, VMOVDQU64

Codificaciones

Codificacion de operandos

A

B

C

D

Coste medido

Descripción#

Operación#

Intel C/C++ compilador intrínseco#

SIMD coma flotante Excepciones#

Otras excepciones#

Fuentes

Descripción

Operación

Intel C/C++ compilador intrínseco

SIMD coma flotante Excepciones

Otras excepciones