vpgatherqq
Gather Packed Quadword with Signed Quadword Indices
VPGATHERQQ ymm1, [base+ymm_idx*scale], ymm_mask
Gathers 64-bit integers using 64-bit indices.
Details
Gathers four 64-bit integers from memory using four 64-bit signed indices packed in a YMM register, with scale and base address, into a YMM destination. The mask register (YMM) controls which elements are gathered; masked-out elements are zeroed and their corresponding mask bits are cleared. All memory accesses execute in parallel, and the instruction causes pipeline serialization.
Pseudocode Operation
for i in 0 to 3:
if mask[64*i+63:64*i] == all_ones_64bit:
addr ← base + index[64*i+63:64*i] * scale
dest[64*i+63:64*i] ← [addr]
mask[64*i+63:64*i] ← all_ones_64bit
else:
dest[64*i+63:64*i] ← 0
mask[64*i+63:64*i] ← 0Example
VPGATHERQQ ymm1, [base+ymm_idx*scale], ymm_mask
Encoding
Binary Layout
VEX
+0
opcode
+3
ModRM
+4
Operands
-
dest
YMM -
mem
Base+Idx -
mask
YMM
Reference (Intel® SDM)
Instruction Forms
| Opcode | Instruction | Op/En | 64/32-bit Mode | CPUID | Description |
|---|---|---|---|---|---|
| EVEX.128.66.0F38.W0 91 /vsib | VPGATHERQD xmm1 {k1}, vm64x | A | V/V | (AVX512VL AND AVX512F) OR AVX10.1 | Using signed qword indices, gather dword values from memory using writemask k1 for mergingmasking. |
| EVEX.256.66.0F38.W0 91 /vsib | VPGATHERQD xmm1 {k1}, vm64y | A | V/V | (AVX512VL AND AVX512F) OR AVX10.1 | Using signed qword indices, gather dword values from memory using writemask k1 for mergingmasking. |
| EVEX.512.66.0F38.W0 91 /vsib | VPGATHERQD ymm1 {k1}, vm64z | A | V/V | AVX512F OR AVX10.1 | Using signed qword indices, gather dword values from memory using writemask k1 for mergingmasking. |
| EVEX.128.66.0F38.W1 91 /vsib | VPGATHERQQ xmm1 {k1}, vm64x | A | V/V | (AVX512VL AND AVX512F) OR AVX10.1 | Using signed qword indices, gather quadword values from memory using writemask k1 for merging-masking. |
| EVEX.256.66.0F38.W1 91 /vsib | VPGATHERQQ ymm1 {k1}, vm64y | A | V/V | (AVX512VL AND AVX512F) OR AVX10.1 | Using signed qword indices, gather quadword values from memory using writemask k1 for merging-masking. |
| EVEX.512.66.0F38.W1 91 /vsib | VPGATHERQQ zmm1 {k1}, vm64z | A | V/V | AVX512F OR AVX10.1 | Using signed qword indices, gather quadword values from memory using writemask k1 for merging-masking. |
Description
A set of 8 doubleword/quadword memory locations pointed to by base address BASE_ADDR and index vector
VINDEX with scale SCALE are gathered. The result is written into a vector register. The elements are specified via the VSIB (i.e., the index register is a vector register, holding packed indices). Elements will only be loaded if their corresponding mask bit is one. If an element’s mask bit is not set, the corresponding element of the destination register is left unchanged. The entire mask register will be set to zero by this instruction unless it triggers an exception.
This instruction can be suspended by an exception if at least one element is already gathered (i.e., if the exception is triggered by an element other than the rightmost one with its mask bit set). When this happens, the destination register and the mask register (k1) are partially updated; those elements that have been gathered are placed into the destination register and have their mask bits set to zero. If any traps or interrupts are pending from already gathered elements, they will be delivered in lieu of the exception; in this case, EFLAG.RF is set to one so an instruction breakpoint is not re-triggered when the instruction is continued.
If the data element size is less than the index element size, the higher part of the destination register and the mask register do not correspond to any elements being gathered. This instruction sets those higher parts to zero. It may update these unused elements to one or both of those registers even if the instruction triggers an exception, and even if the instruction triggers the exception before gathering any elements.
Note that:
• The values may be read from memory in any order. Memory ordering with other instructions follows the Intel64 memory-ordering model.
• Faults are delivered in a right-to-left manner. That is, if a fault is triggered by an element and delivered, all elements closer to the LSB of the destination zmm will be completed (and non-faulting). Individual elements closer to the MSB may or may not be completed. If a given element triggers multiple faults, they are delivered in the conventional order.
VPGATHERQD/VPGATHERQQ—Gather Packed Dword, Packed Qword with Signed Qword Indices Vol. 2C 5-559
• Elements may be gathered in any order, but faults must be delivered in a right-to-left order; thus, elements to the left of a faulting one may be gathered before the fault is delivered. A given implementation of this instruction is repeatable - given the same input values and architectural state, the same set of elements to the left of the faulting one will be gathered.
• This instruction does not perform AC checks, and so will never deliver an AC fault.
• Not valid with 16-bit effective addresses. Will deliver a #UD fault.
• These instructions do not accept zeroing-masking since the 0 values in k1 are used to determine completion.
Note that the presence of VSIB byte is enforced in this instruction. Hence, the instruction will #UD fault if
ModRM.rm is different than 100b.
This instruction has the same disp8*N and alignment rules as for scalar instructions (Tuple 1).
The instruction will #UD fault if the destination vector zmm1 is the same as index vector VINDEX. The instruction will #UD fault if the k0 mask register is specified.
The scaled index may require more bits to represent than the address bits used by the processor (e.g., in 32-bit mode, if the scale is greater than one). In this case, the most significant bits beyond the number of address bits are ignored.
Operation
BASE_ADDR stands for the memory operand base address (a GPR); may not exist VINDEX stands for the memory operand vector of indices (a ZMM register) SCALE stands for the memory operand scalar (1, 2, 4 or 8) DISP is the optional 1 or 4 byte displacement VPGATHERQD (EVEX encoded version) (KL, VL) = (2, 128), (4, 256), (8, 512) FOR j := 0 TO KL-1 i := j * 32 k := j * 64 IF k1[j] THEN DEST[i+31:i] := MEM[BASE_ADDR + (VINDEX[k+63:k]) * SCALE + DISP] k1[j] := 0 ELSE *DEST[i+31:i] := remains unchanged* ; Only merging masking is allowed FI; ENDFOR k1[MAX_KL-1:KL] := 0 DEST[MAXVL-1:VL/2] := 0 VPGATHERQQ (EVEX encoded version) (KL, VL) = (2, 64), (4, 128), (8, 256) FOR j := 0 TO KL-1 i := j * 64 IF k1[j] THEN DEST[i+63:i] := MEM[BASE_ADDR + (VINDEX[i+63:i]) * SCALE + DISP] k1[j] := 0 ELSE *DEST[i+63:i] := remains unchanged* ; Only merging masking is allowed FI; ENDFOR k1[MAX_KL-1:KL] := 0 DEST[MAXVL-1:VL] := 0
Intel C/C++ Compiler Intrinsic Equivalent
VPGATHERQD __m256i _mm512_i64gather_epi32(__m512i vdx, void * base, int scale); VPGATHERQD/VPGATHERQQ—Gather Packed Dword, Packed Qword with Signed Qword Indices Vol. 2C 5-560 VPGATHERQD __m256i _mm512_mask_i64gather_epi32lo(__m256i s, __mmask8 k, __m512i vdx, void * base, int scale); VPGATHERQD __m128i _mm256_mask_i64gather_epi32lo(__m128i s, __mmask8 k, __m256i vdx, void * base, int scale); VPGATHERQD __m128i _mm_mask_i64gather_epi32(__m128i s, __mmask8 k, __m128i vdx, void * base, int scale); VPGATHERQQ __m512i _mm512_i64gather_epi64( __m512i vdx, void * base, int scale); VPGATHERQQ __m512i _mm512_mask_i64gather_epi64(__m512i s, __mmask8 k, __m512i vdx, void * base, int scale); VPGATHERQQ __m256i _mm256_mask_i64gather_epi64(__m256i s, __mmask8 k, __m256i vdx, void * base, int scale); VPGATHERQQ __m128i _mm_mask_i64gather_epi64(__m128i s, __mmask8 k, __m128i vdx, void * base, int scale);
Exceptions
SIMD Floating-Point Exceptions
None.
Other Exceptions
See Table 2-63, “Type E12 Class Exception Conditions.”
VPGATHERQD/VPGATHERQQ—Gather Packed Dword, Packed Qword with Signed Qword Indices Vol. 2C 5-561