Intrin

Usage

use Intrin;

or

import Intrin;

proc isX8664() param : bool

proc isArm64() param : bool

proc vectorType(type eltType, param numElts: int) type

proc implType(type eltType, param numElts: int) type

proc extract(type eltType, param numElts: int, x: vectorType(eltType, numElts), param idx: int) : eltType

idx 0 is the least significant element

proc insert(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: eltType, param idx: int) : x.type

idx 0 is the least significant element

proc splat(type eltType, param numElts: int, x: eltType) : vectorType(eltType, numElts)

proc set(type eltType, param numElts: int, values: numElts*eltType) : vectorType(eltType, numElts)

values(0) is the least significant element

proc loadAligned(type eltType, param numElts: int, ptr: c_ptrConst(eltType)) : vectorType(eltType, numElts)

proc loadUnaligned(type eltType, param numElts: int, ptr: c_ptrConst(eltType)) : vectorType(eltType, numElts)

proc storeAligned(type eltType, param numElts: int, ptr: c_ptr(eltType), x: vectorType(eltType, numElts))

proc storeUnaligned(type eltType, param numElts: int, ptr: c_ptr(eltType), x: vectorType(eltType, numElts))

proc loadMasked(type eltType, param numElts: int, ptr: c_ptrConst(eltType), mask: ?) : vectorType(eltType, numElts)

Load with a mask masked out elements are zeroed out only the most significant bit in each vector lane is considered for the mask

proc gather(type eltType, param numElts: int, ptr: c_ptrConst(eltType), type indexType, indices: ?, param scale: int) : vectorType(eltType, numElts)

proc gatherMasked(type eltType, param numElts: int, ptr: c_ptrConst(eltType), type indexType, indices: ?, param scale: int, mask: ?, src: vectorType(eltType, numElts)) : vectorType(eltType, numElts)

proc swapPairs(type eltType, param numElts: int, x: vectorType(eltType, numElts)) : x.type

proc swapLowHigh(type eltType, param numElts: int, x: vectorType(eltType, numElts)) : x.type

proc reverse(type eltType, param numElts: int, x: vectorType(eltType, numElts)) : x.type

proc rotateLeft(type eltType, param numElts: int, x: vectorType(eltType, numElts)) : x.type

proc rotateRight(type eltType, param numElts: int, x: vectorType(eltType, numElts)) : x.type

proc interleaveLower(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc interleaveUpper(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc deinterleaveLower(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc deinterleaveUpper(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc blendLowHigh(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc add(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc sub(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc mul(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc div(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc neg(type eltType, param numElts: int, x: vectorType(eltType, numElts)) : x.type

proc and(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc or(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc xor(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc not(type eltType, param numElts: int, x: vectorType(eltType, numElts)) : x.type

proc andNot(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc cmpEq(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc cmpNe(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc cmpLt(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc cmpLe(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc cmpGt(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc cmpGe(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc bitSelect(type eltType, param numElts: int, mask: ?, x: vectorType(eltType, numElts), y: x.type) : x.type

proc isAllZeros(type eltType, param numElts: int, x: vectorType(eltType, numElts)) : bool

proc allOnes(type eltType, param numElts: int) : vectorType(eltType, numElts)

proc allZeros(type eltType, param numElts: int) : vectorType(eltType, numElts)

proc moveMask(type eltType, param numElts: int, x: vectorType(eltType, numElts)) : c_int

proc reinterpretCast(type fromEltType, param fromNumElts: int, type toEltType, param toNumElts: int, x: vectorType(fromEltType, fromNumElts)) : vectorType(toEltType, toNumElts)

proc hadd(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

Add pairs of adjacent elements

x: [a, b, c, d] y: [e, f, g, h]

returns: [a+b, e+f, c+d, g+h]

proc sqrt(type eltType, param numElts: int, x: vectorType(eltType, numElts)) : x.type

proc rsqrt(type eltType, param numElts: int, x: vectorType(eltType, numElts)) : x.type

proc fmadd(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type, z: x.type) : x.type

Performs (x*y)+z

proc fmsub(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type, z: x.type) : x.type

Performs (x*y)-z

proc min(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc max(type eltType, param numElts: int, x: vectorType(eltType, numElts), y: x.type) : x.type

proc abs(type eltType, param numElts: int, x: vectorType(eltType, numElts)) : x.type