AVX-512-Mask-Other#

_kadd_mask32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask32
Param Types:: __mmask32 a, __mmask32 b
Param ETypes:: MASK a, MASK b

__mmask32 _kadd_mask32(__mmask32 a, __mmask32 b);

Intel Description

Add 32-bit masks in “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[31:0] := a[31:0] + b[31:0]
k[MAX:32] := 0

_kadd_mask64#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask64
Param Types:: __mmask64 a, __mmask64 b
Param ETypes:: MASK a, MASK b

__mmask64 _kadd_mask64(__mmask64 a, __mmask64 b);

Intel Description

Add 64-bit masks in “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[63:0] := a[63:0] + b[63:0]
k[MAX:64] := 0

_kand_mask32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask32
Param Types:: __mmask32 a, __mmask32 b
Param ETypes:: MASK a, MASK b

__mmask32 _kand_mask32(__mmask32 a, __mmask32 b);

Intel Description

Compute the bitwise AND of 32-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[31:0] := a[31:0] AND b[31:0]
k[MAX:32] := 0

_kand_mask64#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask64
Param Types:: __mmask64 a, __mmask64 b
Param ETypes:: MASK a, MASK b

__mmask64 _kand_mask64(__mmask64 a, __mmask64 b);

Intel Description

Compute the bitwise AND of 64-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[63:0] := a[63:0] AND b[63:0]
k[MAX:64] := 0

_kandn_mask32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask32
Param Types:: __mmask32 a, __mmask32 b
Param ETypes:: MASK a, MASK b

__mmask32 _kandn_mask32(__mmask32 a, __mmask32 b);

Intel Description

Compute the bitwise NOT of 32-bit masks “a” and then AND with “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[31:0] := (NOT a[31:0]) AND b[31:0]
k[MAX:32] := 0

_kandn_mask64#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask64
Param Types:: __mmask64 a, __mmask64 b
Param ETypes:: MASK a, MASK b

__mmask64 _kandn_mask64(__mmask64 a, __mmask64 b);

Intel Description

Compute the bitwise NOT of 64-bit masks “a” and then AND with “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[63:0] := (NOT a[63:0]) AND b[63:0]
k[MAX:64] := 0

_knot_mask32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask32
Param Types:: __mmask32 a
Param ETypes:: MASK a

__mmask32 _knot_mask32(__mmask32 a);

Intel Description

Compute the bitwise NOT of 32-bit mask “a”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[31:0] := NOT a[31:0]
k[MAX:32] := 0

_knot_mask64#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask64
Param Types:: __mmask64 a
Param ETypes:: MASK a

__mmask64 _knot_mask64(__mmask64 a);

Intel Description

Compute the bitwise NOT of 64-bit mask “a”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[63:0] := NOT a[63:0]
k[MAX:64] := 0

_kor_mask32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask32
Param Types:: __mmask32 a, __mmask32 b
Param ETypes:: MASK a, MASK b

__mmask32 _kor_mask32(__mmask32 a, __mmask32 b);

Intel Description

Compute the bitwise OR of 32-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[31:0] := a[31:0] OR b[31:0]
k[MAX:32] := 0

_kor_mask64#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask64
Param Types:: __mmask64 a, __mmask64 b
Param ETypes:: MASK a, MASK b

__mmask64 _kor_mask64(__mmask64 a, __mmask64 b);

Intel Description

Compute the bitwise OR of 64-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[63:0] := a[63:0] OR b[63:0]
k[MAX:64] := 0

_kxnor_mask32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask32
Param Types:: __mmask32 a, __mmask32 b
Param ETypes:: MASK a, MASK b

__mmask32 _kxnor_mask32(__mmask32 a, __mmask32 b);

Intel Description

Compute the bitwise XNOR of 32-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[31:0] := NOT (a[31:0] XOR b[31:0])
k[MAX:32] := 0

_kxnor_mask64#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask64
Param Types:: __mmask64 a, __mmask64 b
Param ETypes:: MASK a, MASK b

__mmask64 _kxnor_mask64(__mmask64 a, __mmask64 b);

Intel Description

Compute the bitwise XNOR of 64-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[63:0] := NOT (a[63:0] XOR b[63:0])
k[MAX:64] := 0

_kxor_mask32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask32
Param Types:: __mmask32 a, __mmask32 b
Param ETypes:: MASK a, MASK b

__mmask32 _kxor_mask32(__mmask32 a, __mmask32 b);

Intel Description

Compute the bitwise XOR of 32-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[31:0] := a[31:0] XOR b[31:0]
k[MAX:32] := 0

_kxor_mask64#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask64
Param Types:: __mmask64 a, __mmask64 b
Param ETypes:: MASK a, MASK b

__mmask64 _kxor_mask64(__mmask64 a, __mmask64 b);

Intel Description

Compute the bitwise XOR of 64-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[63:0] := a[63:0] XOR b[63:0]
k[MAX:64] := 0

_kshiftli_mask32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask32
Param Types:: __mmask32 a, unsigned int count
Param ETypes:: MASK a, IMM count

__mmask32 _kshiftli_mask32(__mmask32 a, unsigned int count);

Intel Description

Shift the bits of 32-bit mask “a” left by “count” while shifting in zeros, and store the least significant 32 bits of the result in “k”.

Intel Implementation Psudeo-Code

k[MAX:0] := 0
IF count[7:0] <= 31
        k[31:0] := a[31:0] << count[7:0]
FI

_kshiftli_mask64#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask64
Param Types:: __mmask64 a, unsigned int count
Param ETypes:: MASK a, IMM count

__mmask64 _kshiftli_mask64(__mmask64 a, unsigned int count);

Intel Description

Shift the bits of 64-bit mask “a” left by “count” while shifting in zeros, and store the least significant 64 bits of the result in “k”.

Intel Implementation Psudeo-Code

k[MAX:0] := 0
IF count[7:0] <= 63
        k[63:0] := a[63:0] << count[7:0]
FI

_kshiftri_mask32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask32
Param Types:: __mmask32 a, unsigned int count
Param ETypes:: MASK a, IMM count

__mmask32 _kshiftri_mask32(__mmask32 a, unsigned int count);

Intel Description

Shift the bits of 32-bit mask “a” right by “count” while shifting in zeros, and store the least significant 32 bits of the result in “k”.

Intel Implementation Psudeo-Code

k[MAX:0] := 0
IF count[7:0] <= 31
        k[31:0] := a[31:0] >> count[7:0]
FI

_kshiftri_mask64#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask64
Param Types:: __mmask64 a, unsigned int count
Param ETypes:: MASK a, IMM count

__mmask64 _kshiftri_mask64(__mmask64 a, unsigned int count);

Intel Description

Shift the bits of 64-bit mask “a” right by “count” while shifting in zeros, and store the least significant 64 bits of the result in “k”.

Intel Implementation Psudeo-Code

k[MAX:0] := 0
IF count[7:0] <= 63
        k[63:0] := a[63:0] >> count[7:0]
FI

_kortest_mask32_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask32 a, __mmask32 b, unsigned char* all_ones
Param ETypes:: MASK a, MASK b, UI8 all_ones

unsigned char _kortest_mask32_u8(__mmask32 a, __mmask32 b, unsigned char* all_ones);

Intel Description

Compute the bitwise OR of 32-bit masks “a” and “b”. If the result is all zeros, store 1 in “dst”, otherwise store 0 in “dst”. If the result is all ones, store 1 in “all_ones”, otherwise store 0 in “all_ones”.

Intel Implementation Psudeo-Code

tmp[31:0] := a[31:0] OR b[31:0]
IF tmp[31:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI
IF tmp[31:0] == 0xFFFFFFFF
        MEM[all_ones+7:all_ones] := 1
ELSE
        MEM[all_ones+7:all_ones] := 0
FI

_kortestz_mask32_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask32 a, __mmask32 b
Param ETypes:: MASK a, MASK b

unsigned char _kortestz_mask32_u8(__mmask32 a, __mmask32 b);

Intel Description

Compute the bitwise OR of 32-bit masks “a” and “b”. If the result is all zeroes, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[31:0] := a[31:0] OR b[31:0]
IF tmp[31:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI

_kortestc_mask32_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask32 a, __mmask32 b
Param ETypes:: MASK a, MASK b

unsigned char _kortestc_mask32_u8(__mmask32 a, __mmask32 b);

Intel Description

Compute the bitwise OR of 32-bit masks “a” and “b”. If the result is all ones, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[31:0] := a[31:0] OR b[31:0]
IF tmp[31:0] == 0xFFFFFFFF
        dst := 1
ELSE
        dst := 0
FI

_kortest_mask64_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask64 a, __mmask64 b, unsigned char* all_ones
Param ETypes:: MASK a, MASK b, UI8 all_ones

unsigned char _kortest_mask64_u8(__mmask64 a, __mmask64 b, unsigned char* all_ones);

Intel Description

Compute the bitwise OR of 64-bit masks “a” and “b”. If the result is all zeros, store 1 in “dst”, otherwise store 0 in “dst”. If the result is all ones, store 1 in “all_ones”, otherwise store 0 in “all_ones”.

Intel Implementation Psudeo-Code

tmp[63:0] := a[63:0] OR b[63:0]
IF tmp[63:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI
IF tmp[7:0] == 0xFFFFFFFFFFFFFFFF
        MEM[all_ones+7:all_ones] := 1
ELSE
        MEM[all_ones+7:all_ones] := 0
FI

_kortestz_mask64_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask64 a, __mmask64 b
Param ETypes:: MASK a, MASK b

unsigned char _kortestz_mask64_u8(__mmask64 a, __mmask64 b);

Intel Description

Compute the bitwise OR of 64-bit masks “a” and “b”. If the result is all zeroes, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[63:0] := a[63:0] OR b[63:0]
IF tmp[63:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI

_kortestc_mask64_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask64 a, __mmask64 b
Param ETypes:: MASK a, MASK b

unsigned char _kortestc_mask64_u8(__mmask64 a, __mmask64 b);

Intel Description

Compute the bitwise OR of 64-bit masks “a” and “b”. If the result is all ones, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[63:0] := a[63:0] OR b[63:0]
IF tmp[63:0] == 0xFFFFFFFFFFFFFFFF
        dst := 1
ELSE
        dst := 0
FI

_ktest_mask32_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask32 a, __mmask32 b, unsigned char* and_not
Param ETypes:: MASK a, MASK b, UI8 and_not

unsigned char _ktest_mask32_u8(__mmask32 a, __mmask32 b, unsigned char* and_not);

Intel Description

Compute the bitwise AND of 32-bit masks “a” and “b”, and if the result is all zeros, store 1 in “dst”, otherwise store 0 in “dst”. Compute the bitwise NOT of “a” and then AND with “b”, if the result is all zeros, store 1 in “and_not”, otherwise store 0 in “and_not”.

Intel Implementation Psudeo-Code

tmp1[31:0] := a[31:0] AND b[31:0]
IF tmp1[31:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI
tmp2[31:0] := (NOT a[31:0]) AND b[31:0]
IF tmp2[31:0] == 0x0
        MEM[and_not+7:and_not] := 1
ELSE
        MEM[and_not+7:and_not] := 0
FI

_ktestz_mask32_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask32 a, __mmask32 b
Param ETypes:: MASK a, MASK b

unsigned char _ktestz_mask32_u8(__mmask32 a, __mmask32 b);

Intel Description

Compute the bitwise AND of 32-bit masks “a” and “b”, and if the result is all zeros, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[31:0] := a[31:0] AND b[31:0]
IF tmp[31:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI

_ktestc_mask32_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask32 a, __mmask32 b
Param ETypes:: MASK a, MASK b

unsigned char _ktestc_mask32_u8(__mmask32 a, __mmask32 b);

Intel Description

Compute the bitwise NOT of 32-bit mask “a” and then AND with “b”, if the result is all zeroes, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[31:0] := (NOT a[31:0]) AND b[31:0]
IF tmp[31:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI

_ktest_mask64_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask64 a, __mmask64 b, unsigned char* and_not
Param ETypes:: MASK a, MASK b, UI8 and_not

unsigned char _ktest_mask64_u8(__mmask64 a, __mmask64 b, unsigned char* and_not);

Intel Description

Compute the bitwise AND of 64-bit masks “a” and “b”, and if the result is all zeros, store 1 in “dst”, otherwise store 0 in “dst”. Compute the bitwise NOT of “a” and then AND with “b”, if the result is all zeros, store 1 in “and_not”, otherwise store 0 in “and_not”.

Intel Implementation Psudeo-Code

tmp1[63:0] := a[63:0] AND b[63:0]
IF tmp1[63:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI
tmp2[63:0] := (NOT a[63:0]) AND b[63:0]
IF tmp2[63:0] == 0x0
        MEM[and_not+7:and_not] := 1
ELSE
        MEM[and_not+7:and_not] := 0
FI

_ktestz_mask64_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask64 a, __mmask64 b
Param ETypes:: MASK a, MASK b

unsigned char _ktestz_mask64_u8(__mmask64 a, __mmask64 b);

Intel Description

Compute the bitwise AND of 64-bit masks “a” and “b”, and if the result is all zeros, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[63:0] := a[63:0] AND b[63:0]
IF tmp[63:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI

_ktestc_mask64_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask64 a, __mmask64 b
Param ETypes:: MASK a, MASK b

unsigned char _ktestc_mask64_u8(__mmask64 a, __mmask64 b);

Intel Description

Compute the bitwise NOT of 64-bit mask “a” and then AND with “b”, if the result is all zeroes, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[63:0] := (NOT a[63:0]) AND b[63:0]
IF tmp[63:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI

_cvtmask32_u32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned int
Param Types:: __mmask32 a
Param ETypes:: MASK a

unsigned int _cvtmask32_u32(__mmask32 a);

Intel Description

Convert 32-bit mask “a” into an integer value, and store the result in “dst”.

Intel Implementation Psudeo-Code

dst := ZeroExtend32(a[31:0])

_cvtmask64_u64#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned __int64
Param Types:: __mmask64 a
Param ETypes:: MASK a

unsigned __int64 _cvtmask64_u64(__mmask64 a);

Intel Description

Convert 64-bit mask “a” into an integer value, and store the result in “dst”.

Intel Implementation Psudeo-Code

dst := ZeroExtend64(a[63:0])

_cvtu32_mask32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask32
Param Types:: unsigned int a
Param ETypes:: UI32 a

__mmask32 _cvtu32_mask32(unsigned int a);

Intel Description

Convert integer value “a” into an 32-bit mask, and store the result in “k”.

Intel Implementation Psudeo-Code

k := ZeroExtend32(a[31:0])

_cvtu64_mask64#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask64
Param Types:: unsigned __int64 a
Param ETypes:: UI64 a

__mmask64 _cvtu64_mask64(unsigned __int64 a);

Intel Description

Convert integer value “a” into an 64-bit mask, and store the result in “k”.

Intel Implementation Psudeo-Code

k := ZeroExtend64(a[63:0])

_kadd_mask8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask8
Param Types:: __mmask8 a, __mmask8 b
Param ETypes:: MASK a, MASK b

__mmask8 _kadd_mask8(__mmask8 a, __mmask8 b);

Intel Description

Add 8-bit masks in “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[7:0] := a[7:0] + b[7:0]
k[MAX:8] := 0

_kadd_mask16#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask16
Param Types:: __mmask16 a, __mmask16 b
Param ETypes:: MASK a, MASK b

__mmask16 _kadd_mask16(__mmask16 a, __mmask16 b);

Intel Description

Add 16-bit masks in “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[15:0] := a[15:0] + b[15:0]
k[MAX:16] := 0

_kand_mask8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask8
Param Types:: __mmask8 a, __mmask8 b
Param ETypes:: MASK a, MASK b

__mmask8 _kand_mask8(__mmask8 a, __mmask8 b);

Intel Description

Compute the bitwise AND of 8-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[7:0] := a[7:0] AND b[7:0]
k[MAX:8] := 0

_kandn_mask8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask8
Param Types:: __mmask8 a, __mmask8 b
Param ETypes:: MASK a, MASK b

__mmask8 _kandn_mask8(__mmask8 a, __mmask8 b);

Intel Description

Compute the bitwise NOT of 8-bit masks “a” and then AND with “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[7:0] := (NOT a[7:0]) AND b[7:0]
k[MAX:8] := 0

_knot_mask8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask8
Param Types:: __mmask8 a
Param ETypes:: MASK a

__mmask8 _knot_mask8(__mmask8 a);

Intel Description

Compute the bitwise NOT of 8-bit mask “a”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[7:0] := NOT a[7:0]
k[MAX:8] := 0

_kor_mask8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask8
Param Types:: __mmask8 a, __mmask8 b
Param ETypes:: MASK a, MASK b

__mmask8 _kor_mask8(__mmask8 a, __mmask8 b);

Intel Description

Compute the bitwise OR of 8-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[7:0] := a[7:0] OR b[7:0]
k[MAX:8] := 0

_kxnor_mask8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask8
Param Types:: __mmask8 a, __mmask8 b
Param ETypes:: MASK a, MASK b

__mmask8 _kxnor_mask8(__mmask8 a, __mmask8 b);

Intel Description

Compute the bitwise XNOR of 8-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[7:0] := NOT (a[7:0] XOR b[7:0])
k[MAX:8] := 0

_kxor_mask8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask8
Param Types:: __mmask8 a, __mmask8 b
Param ETypes:: MASK a, MASK b

__mmask8 _kxor_mask8(__mmask8 a, __mmask8 b);

Intel Description

Compute the bitwise XOR of 8-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[7:0] := a[7:0] XOR b[7:0]
k[MAX:8] := 0

_kshiftli_mask8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask8
Param Types:: __mmask8 a, unsigned int count
Param ETypes:: MASK a, IMM count

__mmask8 _kshiftli_mask8(__mmask8 a, unsigned int count);

Intel Description

Shift the bits of 8-bit mask “a” left by “count” while shifting in zeros, and store the least significant 8 bits of the result in “k”.

Intel Implementation Psudeo-Code

k[MAX:0] := 0
IF count[7:0] <= 7
        k[7:0] := a[7:0] << count[7:0]
FI

_kshiftri_mask8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask8
Param Types:: __mmask8 a, unsigned int count
Param ETypes:: MASK a, IMM count

__mmask8 _kshiftri_mask8(__mmask8 a, unsigned int count);

Intel Description

Shift the bits of 8-bit mask “a” right by “count” while shifting in zeros, and store the least significant 8 bits of the result in “k”.

Intel Implementation Psudeo-Code

k[MAX:0] := 0
IF count[7:0] <= 7
        k[7:0] := a[7:0] >> count[7:0]
FI

_kortest_mask8_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask8 a, __mmask8 b, unsigned char* all_ones
Param ETypes:: MASK a, MASK b, UI8 all_ones

unsigned char _kortest_mask8_u8(__mmask8 a, __mmask8 b, unsigned char* all_ones);

Intel Description

Compute the bitwise OR of 8-bit masks “a” and “b”. If the result is all zeros, store 1 in “dst”, otherwise store 0 in “dst”. If the result is all ones, store 1 in “all_ones”, otherwise store 0 in “all_ones”.

Intel Implementation Psudeo-Code

tmp[7:0] := a[7:0] OR b[7:0]
IF tmp[7:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI
IF tmp[7:0] == 0xFF
        MEM[all_ones+7:all_ones] := 1
ELSE
        MEM[all_ones+7:all_ones] := 0
FI

_kortestz_mask8_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask8 a, __mmask8 b
Param ETypes:: MASK a, MASK b

unsigned char _kortestz_mask8_u8(__mmask8 a, __mmask8 b);

Intel Description

Compute the bitwise OR of 8-bit masks “a” and “b”. If the result is all zeroes, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[7:0] := a[7:0] OR b[7:0]
IF tmp[7:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI

_kortestc_mask8_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask8 a, __mmask8 b
Param ETypes:: MASK a, MASK b

unsigned char _kortestc_mask8_u8(__mmask8 a, __mmask8 b);

Intel Description

Compute the bitwise OR of 8-bit masks “a” and “b”. If the result is all ones, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[7:0] := a[7:0] OR b[7:0]
IF tmp[7:0] == 0xFF
        dst := 1
ELSE
        dst := 0
FI

_ktest_mask8_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask8 a, __mmask8 b, unsigned char* and_not
Param ETypes:: MASK a, MASK b, UI8 and_not

unsigned char _ktest_mask8_u8(__mmask8 a, __mmask8 b, unsigned char* and_not);

Intel Description

Compute the bitwise AND of 8-bit masks “a” and “b”, and if the result is all zeros, store 1 in “dst”, otherwise store 0 in “dst”. Compute the bitwise NOT of “a” and then AND with “b”, if the result is all zeros, store 1 in “and_not”, otherwise store 0 in “and_not”.

Intel Implementation Psudeo-Code

tmp1[7:0] := a[7:0] AND b[7:0]
IF tmp1[7:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI
tmp2[7:0] := (NOT a[7:0]) AND b[7:0]
IF tmp2[7:0] == 0x0
        MEM[and_not+7:and_not] := 1
ELSE
        MEM[and_not+7:and_not] := 0
FI

_ktestz_mask8_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask8 a, __mmask8 b
Param ETypes:: MASK a, MASK b

unsigned char _ktestz_mask8_u8(__mmask8 a, __mmask8 b);

Intel Description

Compute the bitwise AND of 8-bit masks “a” and “b”, and if the result is all zeros, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[7:0] := a[7:0] AND b[7:0]
IF tmp[7:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI

_ktestc_mask8_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask8 a, __mmask8 b
Param ETypes:: MASK a, MASK b

unsigned char _ktestc_mask8_u8(__mmask8 a, __mmask8 b);

Intel Description

Compute the bitwise NOT of 8-bit mask “a” and then AND with “b”, if the result is all zeroes, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[7:0] := (NOT a[7:0]) AND b[7:0]
IF tmp[7:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI

_ktest_mask16_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask16 a, __mmask16 b, unsigned char* and_not
Param ETypes:: MASK a, MASK b, UI8 and_not

unsigned char _ktest_mask16_u8(__mmask16 a, __mmask16 b, unsigned char* and_not);

Intel Description

Compute the bitwise AND of 16-bit masks “a” and “b”, and if the result is all zeros, store 1 in “dst”, otherwise store 0 in “dst”. Compute the bitwise NOT of “a” and then AND with “b”, if the result is all zeros, store 1 in “and_not”, otherwise store 0 in “and_not”.

Intel Implementation Psudeo-Code

tmp1[15:0] := a[15:0] AND b[15:0]
IF tmp1[15:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI
tmp2[15:0] := (NOT a[15:0]) AND b[15:0]
IF tmp2[15:0] == 0x0
        MEM[and_not+7:and_not] := 1
ELSE
        MEM[and_not+7:and_not] := 0
FI

_ktestz_mask16_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask16 a, __mmask16 b
Param ETypes:: MASK a, MASK b

unsigned char _ktestz_mask16_u8(__mmask16 a, __mmask16 b);

Intel Description

Compute the bitwise AND of 16-bit masks “a” and “b”, and if the result is all zeros, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[15:0] := a[15:0] AND b[15:0]
IF tmp[15:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI

_ktestc_mask16_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask16 a, __mmask16 b
Param ETypes:: MASK a, MASK b

unsigned char _ktestc_mask16_u8(__mmask16 a, __mmask16 b);

Intel Description

Compute the bitwise NOT of 16-bit mask “a” and then AND with “b”, if the result is all zeroes, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[15:0] := (NOT a[15:0]) AND b[15:0]
IF tmp[15:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI

_cvtmask8_u32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned int
Param Types:: __mmask8 a
Param ETypes:: MASK a

unsigned int _cvtmask8_u32(__mmask8 a);

Intel Description

Convert 8-bit mask “a” into an integer value, and store the result in “dst”.

Intel Implementation Psudeo-Code

dst := ZeroExtend32(a[7:0])

_cvtu32_mask8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask8
Param Types:: unsigned int a
Param ETypes:: UI8 a

__mmask8 _cvtu32_mask8(unsigned int a);

Intel Description

Convert integer value “a” into an 8-bit mask, and store the result in “k”.

Intel Implementation Psudeo-Code

k := a[7:0]

_kand_mask16#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask16
Param Types:: __mmask16 a, __mmask16 b
Param ETypes:: MASK a, MASK b

__mmask16 _kand_mask16(__mmask16 a, __mmask16 b);

Intel Description

Compute the bitwise AND of 16-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[15:0] := a[15:0] AND b[15:0]
k[MAX:16] := 0

_kandn_mask16#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask16
Param Types:: __mmask16 a, __mmask16 b
Param ETypes:: MASK a, MASK b

__mmask16 _kandn_mask16(__mmask16 a, __mmask16 b);

Intel Description

Compute the bitwise NOT of 16-bit masks “a” and then AND with “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[15:0] := (NOT a[15:0]) AND b[15:0]
k[MAX:16] := 0

_knot_mask16#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask16
Param Types:: __mmask16 a
Param ETypes:: MASK a

__mmask16 _knot_mask16(__mmask16 a);

Intel Description

Compute the bitwise NOT of 16-bit mask “a”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[15:0] := NOT a[15:0]
k[MAX:16] := 0

_kor_mask16#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask16
Param Types:: __mmask16 a, __mmask16 b
Param ETypes:: MASK a, MASK b

__mmask16 _kor_mask16(__mmask16 a, __mmask16 b);

Intel Description

Compute the bitwise OR of 16-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[15:0] := a[15:0] OR b[15:0]
k[MAX:16] := 0

_kxnor_mask16#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask16
Param Types:: __mmask16 a, __mmask16 b
Param ETypes:: MASK a, MASK b

__mmask16 _kxnor_mask16(__mmask16 a, __mmask16 b);

Intel Description

Compute the bitwise XNOR of 16-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[15:0] := NOT (a[15:0] XOR b[15:0])
k[MAX:16] := 0

_kxor_mask16#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask16
Param Types:: __mmask16 a, __mmask16 b
Param ETypes:: MASK a, MASK b

__mmask16 _kxor_mask16(__mmask16 a, __mmask16 b);

Intel Description

Compute the bitwise XOR of 16-bit masks “a” and “b”, and store the result in “k”.

Intel Implementation Psudeo-Code

k[15:0] := a[15:0] XOR b[15:0]
k[MAX:16] := 0

_kshiftli_mask16#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask16
Param Types:: __mmask16 a, unsigned int count
Param ETypes:: MASK a, IMM count

__mmask16 _kshiftli_mask16(__mmask16 a, unsigned int count);

Intel Description

Shift the bits of 16-bit mask “a” left by “count” while shifting in zeros, and store the least significant 16 bits of the result in “k”.

Intel Implementation Psudeo-Code

k[MAX:0] := 0
IF count[7:0] <= 15
        k[15:0] := a[15:0] << count[7:0]
FI

_kshiftri_mask16#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask16
Param Types:: __mmask16 a, unsigned int count
Param ETypes:: MASK a, IMM count

__mmask16 _kshiftri_mask16(__mmask16 a, unsigned int count);

Intel Description

Shift the bits of 16-bit mask “a” right by “count” while shifting in zeros, and store the least significant 16 bits of the result in “k”.

Intel Implementation Psudeo-Code

k[MAX:0] := 0
IF count[7:0] <= 15
        k[15:0] := a[15:0] >> count[7:0]
FI

_kortest_mask16_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask16 a, __mmask16 b, unsigned char* all_ones
Param ETypes:: MASK a, MASK b, UI8 all_ones

unsigned char _kortest_mask16_u8(__mmask16 a, __mmask16 b, unsigned char* all_ones);

Intel Description

Compute the bitwise OR of 16-bit masks “a” and “b”. If the result is all zeros, store 1 in “dst”, otherwise store 0 in “dst”. If the result is all ones, store 1 in “all_ones”, otherwise store 0 in “all_ones”.

Intel Implementation Psudeo-Code

tmp[15:0] := a[15:0] OR b[15:0]
IF tmp[15:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI
IF tmp[15:0] == 0xFFFF
        MEM[all_ones+7:all_ones] := 1
ELSE
        MEM[all_ones+7:all_ones] := 0
FI

_kortestz_mask16_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask16 a, __mmask16 b
Param ETypes:: MASK a, MASK b

unsigned char _kortestz_mask16_u8(__mmask16 a, __mmask16 b);

Intel Description

Compute the bitwise OR of 16-bit masks “a” and “b”. If the result is all zeroes, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[15:0] := a[15:0] OR b[15:0]
IF tmp[15:0] == 0x0
        dst := 1
ELSE
        dst := 0
FI

_kortestc_mask16_u8#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned char
Param Types:: __mmask16 a, __mmask16 b
Param ETypes:: MASK a, MASK b

unsigned char _kortestc_mask16_u8(__mmask16 a, __mmask16 b);

Intel Description

Compute the bitwise OR of 16-bit masks “a” and “b”. If the result is all ones, store 1 in “dst”, otherwise store 0 in “dst”.

Intel Implementation Psudeo-Code

tmp[15:0] := a[15:0] OR b[15:0]
IF tmp[15:0] == 0xFFFF
        dst := 1
ELSE
        dst := 0
FI

_cvtmask16_u32#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: unsigned int
Param Types:: __mmask16 a
Param ETypes:: MASK a

unsigned int _cvtmask16_u32(__mmask16 a);

Intel Description

Convert 16-bit mask “a” into an integer value, and store the result in “dst”.

Intel Implementation Psudeo-Code

dst := ZeroExtend32(a[15:0])

_cvtu32_mask16#

Tech:: AVX-512
Category:: Mask
Header:: immintrin.h
Searchable:: AVX-512-Mask-Other
Return Type:: __mmask16
Param Types:: unsigned int a
Param ETypes:: UI16 a

__mmask16 _cvtu32_mask16(unsigned int a);

Intel Description

Convert integer value “a” into an 16-bit mask, and store the result in “k”.

Intel Implementation Psudeo-Code

k := ZeroExtend16(a[15:0])

AVX-512-Mask-Other

Contents

AVX-512-Mask-Other#

_kadd_mask32#

_kadd_mask64#

_kand_mask32#

_kand_mask64#

_kandn_mask32#

_kandn_mask64#

_knot_mask32#

_knot_mask64#

_kor_mask32#

_kor_mask64#

_kxnor_mask32#

_kxnor_mask64#

_kxor_mask32#

_kxor_mask64#

_kshiftli_mask32#

_kshiftli_mask64#

_kshiftri_mask32#

_kshiftri_mask64#

_kortest_mask32_u8#

_kortestz_mask32_u8#

_kortestc_mask32_u8#

_kortest_mask64_u8#

_kortestz_mask64_u8#

_kortestc_mask64_u8#

_ktest_mask32_u8#

_ktestz_mask32_u8#

_ktestc_mask32_u8#

_ktest_mask64_u8#

_ktestz_mask64_u8#

_ktestc_mask64_u8#

_cvtmask32_u32#

_cvtmask64_u64#

_cvtu32_mask32#

_cvtu64_mask64#

_kadd_mask8#

_kadd_mask16#

_kand_mask8#

_kandn_mask8#

_knot_mask8#

_kor_mask8#

_kxnor_mask8#

_kxor_mask8#

_kshiftli_mask8#

_kshiftri_mask8#

_kortest_mask8_u8#

_kortestz_mask8_u8#

_kortestc_mask8_u8#

_ktest_mask8_u8#

_ktestz_mask8_u8#

_ktestc_mask8_u8#

_ktest_mask16_u8#

_ktestz_mask16_u8#

_ktestc_mask16_u8#

_cvtmask8_u32#

_cvtu32_mask8#

_kand_mask16#

_kandn_mask16#

_knot_mask16#

_kor_mask16#

_kxnor_mask16#

_kxor_mask16#

_kshiftli_mask16#

_kshiftri_mask16#

_kortest_mask16_u8#

_kortestz_mask16_u8#

_kortestc_mask16_u8#

_cvtmask16_u32#

_cvtu32_mask16#