LLVM.Extra.Multi.Vector

Documentation

newtype T n a

Constructors

Cons (Repr n a)

Instances

Positive n => C (T n)

Defined in LLVM.Extra.Multi.Class

Associated Types

type Size (T n)

Methods

switch :: f T0 -> f (T (Size (T n))) -> f (T n)

(Positive n, Additive a) => Additive (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

zero :: T n a

add :: T n a -> T n a -> CodeGenFunction r (T n a)

sub :: T n a -> T n a -> CodeGenFunction r (T n a)

neg :: T n a -> CodeGenFunction r (T n a)

(Positive n, Algebraic a) => Algebraic (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

sqrt :: T n a -> CodeGenFunction r (T n a)

(Positive n, Comparison a) => Comparison (T n a)

Defined in LLVM.Extra.Multi.Vector

Associated Types

type CmpResult (T n a)

Methods

cmp :: CmpPredicate -> T n a -> T n a -> CodeGenFunction r (CmpResult (T n a))

(Positive n, Field a) => Field (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

fdiv :: T n a -> T n a -> CodeGenFunction r (T n a)

(Positive n, FloatingComparison a) => FloatingComparison (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

fcmp :: FPPredicate -> T n a -> T n a -> CodeGenFunction r (CmpResult (T n a))

(Positive n, Fraction a) => Fraction (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

truncate :: T n a -> CodeGenFunction r (T n a)

fraction :: T n a -> CodeGenFunction r (T n a)

(Positive n, IntegerConstant a) => IntegerConstant (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Integer -> T n a

(Positive n, Logic a) => Logic (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

and :: T n a -> T n a -> CodeGenFunction r (T n a)

or :: T n a -> T n a -> CodeGenFunction r (T n a)

xor :: T n a -> T n a -> CodeGenFunction r (T n a)

inv :: T n a -> CodeGenFunction r (T n a)

(Positive n, PseudoModule a) => PseudoModule (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

scale :: Scalar (T n a) -> T n a -> CodeGenFunction r (T n a)

(Positive n, PseudoRing a) => PseudoRing (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

mul :: T n a -> T n a -> CodeGenFunction r (T n a)

(Positive n, RationalConstant a) => RationalConstant (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

fromRational' :: Rational -> T n a

(Positive n, Real a) => Real (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

min :: T n a -> T n a -> CodeGenFunction r (T n a)

max :: T n a -> T n a -> CodeGenFunction r (T n a)

abs :: T n a -> CodeGenFunction r (T n a)

signum :: T n a -> CodeGenFunction r (T n a)

(Positive n, Transcendental a) => Transcendental (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

pi :: CodeGenFunction r (T n a)

sin :: T n a -> CodeGenFunction r (T n a)

cos :: T n a -> CodeGenFunction r (T n a)

exp :: T n a -> CodeGenFunction r (T n a)

log :: T n a -> CodeGenFunction r (T n a)

pow :: T n a -> T n a -> CodeGenFunction r (T n a)

(IsType (Struct (Repr n a)), IsSized (Struct (Repr n a)), Positive n, C a, C (Repr n a)) => C (T n a)

Defined in LLVM.Extra.Memory

Associated Types

type Struct (T n a)

Methods

load :: Value (Ptr (Struct (T n a))) -> CodeGenFunction r (T n a)

store :: T n a -> Value (Ptr (Struct (T n a))) -> CodeGenFunction r ()

decompose :: Value (Struct (T n a)) -> CodeGenFunction r (T n a)

compose :: T n a -> CodeGenFunction r (Value (Struct (T n a)))

(Positive n, C a) => Phi (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

phi :: BasicBlock -> T n a -> CodeGenFunction r (T n a)

addPhi :: BasicBlock -> T n a -> T n a -> CodeGenFunction r ()

(Positive n, C a) => Undefined (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

undef :: T n a

(Positive n, C a) => Zero (T n a)

Defined in LLVM.Extra.Multi.Vector

Methods

zero :: T n a

type Size (T n)

Defined in LLVM.Extra.Multi.Class

type Size (T n) = n

type CmpResult (T n a)

Defined in LLVM.Extra.Multi.Vector

type CmpResult (T n a) = T n Bool

type Scalar (T n a)

Defined in LLVM.Extra.Multi.Vector

type Scalar (T n a) = T n (Scalar a)

type Struct (T n a)

Defined in LLVM.Extra.Memory

type Struct (T n a) = Struct (Repr n a)

consPrim :: Repr n a ~ Value n ar => Value n ar -> T n a

deconsPrim :: Repr n a ~ Value n ar => T n a -> Value n ar

class C a => C a where

Associated Types

type Repr n a

Methods

cons :: Positive n => Vector n a -> T n a

undef :: Positive n => T n a

zero :: Positive n => T n a

phi :: Positive n => BasicBlock -> T n a -> CodeGenFunction r (T n a)

addPhi :: Positive n => BasicBlock -> T n a -> T n a -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n a -> T n a -> CodeGenFunction r (T m a)

extract :: Positive n => Value Word32 -> T n a -> CodeGenFunction r (T a)

insert :: Positive n => Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)

Instances

C Int16

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Int16

Methods

cons :: Positive n => Vector n Int16 -> T n Int16

undef :: Positive n => T n Int16

zero :: Positive n => T n Int16

phi :: Positive n => BasicBlock -> T n Int16 -> CodeGenFunction r (T n Int16)

addPhi :: Positive n => BasicBlock -> T n Int16 -> T n Int16 -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Int16 -> T n Int16 -> CodeGenFunction r (T m Int16)

extract :: Positive n => Value Word32 -> T n Int16 -> CodeGenFunction r (T Int16)

insert :: Positive n => Value Word32 -> T Int16 -> T n Int16 -> CodeGenFunction r (T n Int16)

C Int32

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Int32

Methods

cons :: Positive n => Vector n Int32 -> T n Int32

undef :: Positive n => T n Int32

zero :: Positive n => T n Int32

phi :: Positive n => BasicBlock -> T n Int32 -> CodeGenFunction r (T n Int32)

addPhi :: Positive n => BasicBlock -> T n Int32 -> T n Int32 -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Int32 -> T n Int32 -> CodeGenFunction r (T m Int32)

extract :: Positive n => Value Word32 -> T n Int32 -> CodeGenFunction r (T Int32)

insert :: Positive n => Value Word32 -> T Int32 -> T n Int32 -> CodeGenFunction r (T n Int32)

C Int64

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Int64

Methods

cons :: Positive n => Vector n Int64 -> T n Int64

undef :: Positive n => T n Int64

zero :: Positive n => T n Int64

phi :: Positive n => BasicBlock -> T n Int64 -> CodeGenFunction r (T n Int64)

addPhi :: Positive n => BasicBlock -> T n Int64 -> T n Int64 -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Int64 -> T n Int64 -> CodeGenFunction r (T m Int64)

extract :: Positive n => Value Word32 -> T n Int64 -> CodeGenFunction r (T Int64)

insert :: Positive n => Value Word32 -> T Int64 -> T n Int64 -> CodeGenFunction r (T n Int64)

C Int8

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Int8

Methods

cons :: Positive n => Vector n Int8 -> T n Int8

undef :: Positive n => T n Int8

zero :: Positive n => T n Int8

phi :: Positive n => BasicBlock -> T n Int8 -> CodeGenFunction r (T n Int8)

addPhi :: Positive n => BasicBlock -> T n Int8 -> T n Int8 -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Int8 -> T n Int8 -> CodeGenFunction r (T m Int8)

extract :: Positive n => Value Word32 -> T n Int8 -> CodeGenFunction r (T Int8)

insert :: Positive n => Value Word32 -> T Int8 -> T n Int8 -> CodeGenFunction r (T n Int8)

C Word16

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Word16

Methods

cons :: Positive n => Vector n Word16 -> T n Word16

undef :: Positive n => T n Word16

zero :: Positive n => T n Word16

phi :: Positive n => BasicBlock -> T n Word16 -> CodeGenFunction r (T n Word16)

addPhi :: Positive n => BasicBlock -> T n Word16 -> T n Word16 -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Word16 -> T n Word16 -> CodeGenFunction r (T m Word16)

extract :: Positive n => Value Word32 -> T n Word16 -> CodeGenFunction r (T Word16)

insert :: Positive n => Value Word32 -> T Word16 -> T n Word16 -> CodeGenFunction r (T n Word16)

C Word32

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Word32

Methods

cons :: Positive n => Vector n Word32 -> T n Word32

undef :: Positive n => T n Word32

zero :: Positive n => T n Word32

phi :: Positive n => BasicBlock -> T n Word32 -> CodeGenFunction r (T n Word32)

addPhi :: Positive n => BasicBlock -> T n Word32 -> T n Word32 -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Word32 -> T n Word32 -> CodeGenFunction r (T m Word32)

extract :: Positive n => Value Word32 -> T n Word32 -> CodeGenFunction r (T Word32)

insert :: Positive n => Value Word32 -> T Word32 -> T n Word32 -> CodeGenFunction r (T n Word32)

C Word64

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Word64

Methods

cons :: Positive n => Vector n Word64 -> T n Word64

undef :: Positive n => T n Word64

zero :: Positive n => T n Word64

phi :: Positive n => BasicBlock -> T n Word64 -> CodeGenFunction r (T n Word64)

addPhi :: Positive n => BasicBlock -> T n Word64 -> T n Word64 -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Word64 -> T n Word64 -> CodeGenFunction r (T m Word64)

extract :: Positive n => Value Word32 -> T n Word64 -> CodeGenFunction r (T Word64)

insert :: Positive n => Value Word32 -> T Word64 -> T n Word64 -> CodeGenFunction r (T n Word64)

C Word8

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Word8

Methods

cons :: Positive n => Vector n Word8 -> T n Word8

undef :: Positive n => T n Word8

zero :: Positive n => T n Word8

phi :: Positive n => BasicBlock -> T n Word8 -> CodeGenFunction r (T n Word8)

addPhi :: Positive n => BasicBlock -> T n Word8 -> T n Word8 -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Word8 -> T n Word8 -> CodeGenFunction r (T m Word8)

extract :: Positive n => Value Word32 -> T n Word8 -> CodeGenFunction r (T Word8)

insert :: Positive n => Value Word32 -> T Word8 -> T n Word8 -> CodeGenFunction r (T n Word8)

C Bool8

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Bool8

Methods

cons :: Positive n => Vector n Bool8 -> T n Bool8

undef :: Positive n => T n Bool8

zero :: Positive n => T n Bool8

phi :: Positive n => BasicBlock -> T n Bool8 -> CodeGenFunction r (T n Bool8)

addPhi :: Positive n => BasicBlock -> T n Bool8 -> T n Bool8 -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Bool8 -> T n Bool8 -> CodeGenFunction r (T m Bool8)

extract :: Positive n => Value Word32 -> T n Bool8 -> CodeGenFunction r (T Bool8)

insert :: Positive n => Value Word32 -> T Bool8 -> T n Bool8 -> CodeGenFunction r (T n Bool8)

C Bool

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Bool

Methods

cons :: Positive n => Vector n Bool -> T n Bool

undef :: Positive n => T n Bool

zero :: Positive n => T n Bool

phi :: Positive n => BasicBlock -> T n Bool -> CodeGenFunction r (T n Bool)

addPhi :: Positive n => BasicBlock -> T n Bool -> T n Bool -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Bool -> T n Bool -> CodeGenFunction r (T m Bool)

extract :: Positive n => Value Word32 -> T n Bool -> CodeGenFunction r (T Bool)

insert :: Positive n => Value Word32 -> T Bool -> T n Bool -> CodeGenFunction r (T n Bool)

C Double

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Double

Methods

cons :: Positive n => Vector n Double -> T n Double

undef :: Positive n => T n Double

zero :: Positive n => T n Double

phi :: Positive n => BasicBlock -> T n Double -> CodeGenFunction r (T n Double)

addPhi :: Positive n => BasicBlock -> T n Double -> T n Double -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Double -> T n Double -> CodeGenFunction r (T m Double)

extract :: Positive n => Value Word32 -> T n Double -> CodeGenFunction r (T Double)

insert :: Positive n => Value Word32 -> T Double -> T n Double -> CodeGenFunction r (T n Double)

C Float

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Float

Methods

cons :: Positive n => Vector n Float -> T n Float

undef :: Positive n => T n Float

zero :: Positive n => T n Float

phi :: Positive n => BasicBlock -> T n Float -> CodeGenFunction r (T n Float)

addPhi :: Positive n => BasicBlock -> T n Float -> T n Float -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Float -> T n Float -> CodeGenFunction r (T m Float)

extract :: Positive n => Value Word32 -> T n Float -> CodeGenFunction r (T Float)

insert :: Positive n => Value Word32 -> T Float -> T n Float -> CodeGenFunction r (T n Float)

C Int

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Int

Methods

cons :: Positive n => Vector n Int -> T n Int

undef :: Positive n => T n Int

zero :: Positive n => T n Int

phi :: Positive n => BasicBlock -> T n Int -> CodeGenFunction r (T n Int)

addPhi :: Positive n => BasicBlock -> T n Int -> T n Int -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Int -> T n Int -> CodeGenFunction r (T m Int)

extract :: Positive n => Value Word32 -> T n Int -> CodeGenFunction r (T Int)

insert :: Positive n => Value Word32 -> T Int -> T n Int -> CodeGenFunction r (T n Int)

C Word

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n Word

Methods

cons :: Positive n => Vector n Word -> T n Word

undef :: Positive n => T n Word

zero :: Positive n => T n Word

phi :: Positive n => BasicBlock -> T n Word -> CodeGenFunction r (T n Word)

addPhi :: Positive n => BasicBlock -> T n Word -> T n Word -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n Word -> T n Word -> CodeGenFunction r (T m Word)

extract :: Positive n => Value Word32 -> T n Word -> CodeGenFunction r (T Word)

insert :: Positive n => Value Word32 -> T Word -> T n Word -> CodeGenFunction r (T n Word)

C tuple => C (Tuple tuple)

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n (Tuple tuple)

Methods

cons :: Positive n => Vector n (Tuple tuple) -> T n (Tuple tuple)

undef :: Positive n => T n (Tuple tuple)

zero :: Positive n => T n (Tuple tuple)

phi :: Positive n => BasicBlock -> T n (Tuple tuple) -> CodeGenFunction r (T n (Tuple tuple))

addPhi :: Positive n => BasicBlock -> T n (Tuple tuple) -> T n (Tuple tuple) -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n (Tuple tuple) -> T n (Tuple tuple) -> CodeGenFunction r (T m (Tuple tuple))

extract :: Positive n => Value Word32 -> T n (Tuple tuple) -> CodeGenFunction r (T (Tuple tuple))

insert :: Positive n => Value Word32 -> T (Tuple tuple) -> T n (Tuple tuple) -> CodeGenFunction r (T n (Tuple tuple))

(Flags flags, MultiVector a) => C (Number flags a)

Defined in LLVM.Extra.FastMath

Associated Types

type Repr n (Number flags a)

Methods

cons :: Positive n => Vector n (Number flags a) -> T n (Number flags a)

undef :: Positive n => T n (Number flags a)

zero :: Positive n => T n (Number flags a)

phi :: Positive n => BasicBlock -> T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

addPhi :: Positive n => BasicBlock -> T n (Number flags a) -> T n (Number flags a) -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n (Number flags a) -> T n (Number flags a) -> CodeGenFunction r (T m (Number flags a))

extract :: Positive n => Value Word32 -> T n (Number flags a) -> CodeGenFunction r (T (Number flags a))

insert :: Positive n => Value Word32 -> T (Number flags a) -> T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

(C a, C b) => C (a, b)

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n (a, b)

Methods

cons :: Positive n => Vector n (a, b) -> T n (a, b)

undef :: Positive n => T n (a, b)

zero :: Positive n => T n (a, b)

phi :: Positive n => BasicBlock -> T n (a, b) -> CodeGenFunction r (T n (a, b))

addPhi :: Positive n => BasicBlock -> T n (a, b) -> T n (a, b) -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n (a, b) -> T n (a, b) -> CodeGenFunction r (T m (a, b))

extract :: Positive n => Value Word32 -> T n (a, b) -> CodeGenFunction r (T (a, b))

insert :: Positive n => Value Word32 -> T (a, b) -> T n (a, b) -> CodeGenFunction r (T n (a, b))

(C a, C b, C c) => C (a, b, c)

Defined in LLVM.Extra.Multi.Vector

Associated Types

type Repr n (a, b, c)

Methods

cons :: Positive n => Vector n (a, b, c) -> T n (a, b, c)

undef :: Positive n => T n (a, b, c)

zero :: Positive n => T n (a, b, c)

phi :: Positive n => BasicBlock -> T n (a, b, c) -> CodeGenFunction r (T n (a, b, c))

addPhi :: Positive n => BasicBlock -> T n (a, b, c) -> T n (a, b, c) -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n (a, b, c) -> T n (a, b, c) -> CodeGenFunction r (T m (a, b, c))

extract :: Positive n => Value Word32 -> T n (a, b, c) -> CodeGenFunction r (T (a, b, c))

insert :: Positive n => Value Word32 -> T (a, b, c) -> T n (a, b, c) -> CodeGenFunction r (T n (a, b, c))

type Value n a = Value (Vector n a)

map :: (Positive n, C a, C b) => (T a -> CodeGenFunction r (T b)) -> T n a -> CodeGenFunction r (T n b)

zip :: T n a -> T n b -> T n (a, b)

zip3 :: T n a -> T n b -> T n c -> T n (a, b, c)

unzip :: T n (a, b) -> (T n a, T n b)

unzip3 :: T n (a, b, c) -> (T n a, T n b, T n c)

replicate :: (Positive n, C a) => T a -> CodeGenFunction r (T n a)

iterate :: (Positive n, C a) => (T a -> CodeGenFunction r (T a)) -> T a -> CodeGenFunction r (T n a)

take :: (Positive n, Positive m, C a) => T n a -> CodeGenFunction r (T m a)

takeRev :: (Positive n, Positive m, C a) => T n a -> CodeGenFunction r (T m a)

sum :: (Positive n, Additive a) => T n a -> CodeGenFunction r (T a)

dotProduct :: (Positive n, PseudoRing a) => T n a -> T n a -> CodeGenFunction r (T a)

cumulate :: (Positive n, Additive a) => T a -> T n a -> CodeGenFunction r (T a, T n a)

cumulate1 :: (Positive n, Additive a) => T n a -> CodeGenFunction r (T n a)

Needs (log n) vector additions

lift1 :: (Repr n a -> Repr n b) -> T n a -> T n b

modify :: (Positive n, C a) => Value Word32 -> (T a -> CodeGenFunction r (T a)) -> T n a -> CodeGenFunction r (T n a)

assemble :: (Positive n, C a) => [T a] -> CodeGenFunction r (T n a)

dissect :: (Positive n, C a) => T n a -> CodeGenFunction r [T a]

dissectList :: (Positive n, C a) => T n a -> [CodeGenFunction r (T a)]

assemble1 :: (Positive n, C a) => T [] (T a) -> CodeGenFunction r (T n a)

dissect1 :: (Positive n, C a) => T n a -> CodeGenFunction r (T [] (T a))

dissectList1 :: (Positive n, C a) => T n a -> T [] (CodeGenFunction r (T a))

assembleFromVector :: (Positive n, C a) => Vector n (T a) -> CodeGenFunction r (T n a)

reverse :: (Positive n, C a) => T n a -> CodeGenFunction r (T n a)

rotateUp :: (Positive n, C a) => T n a -> CodeGenFunction r (T n a)

Rotate one element towards the higher elements.

I don't want to call it rotateLeft or rotateRight, because there is no prefered layout for the vector elements. In Intel's instruction manual vector elements are indexed like the bits, that is from right to left. However, when working with Haskell list and enumeration syntax, the start index is left.

rotateDown :: (Positive n, C a) => T n a -> CodeGenFunction r (T n a)

shiftUp :: (Positive n, C a) => T a -> T n a -> CodeGenFunction r (T a, T n a)

shiftDown :: (Positive n, C a) => T a -> T n a -> CodeGenFunction r (T a, T n a)

shiftUpMultiZero :: (Positive n, C a) => Int -> T n a -> CodeGenFunction r (T n a)

shiftDownMultiZero :: (Positive n, C a) => Int -> T n a -> CodeGenFunction r (T n a)

shiftUpMultiUndef :: (Positive n, C a) => Int -> T n a -> CodeGenFunction r (T n a)

shiftDownMultiUndef :: (Positive n, C a) => Int -> T n a -> CodeGenFunction r (T n a)

undefPrimitive :: (Positive n, IsPrimitive al, Repr n a ~ Value n al) => T n a

shufflePrimitive :: (Positive n, Positive m, IsPrimitive al, Repr a ~ Value al, Repr n a ~ Value n al, Repr m a ~ Value m al) => ConstValue (Vector m Word32) -> T n a -> T n a -> CodeGenFunction r (T m a)

extractPrimitive :: (Positive n, IsPrimitive al, Repr a ~ Value al, Repr n a ~ Value n al) => Value Word32 -> T n a -> CodeGenFunction r (T a)

insertPrimitive :: (Positive n, IsPrimitive al, Repr a ~ Value al, Repr n a ~ Value n al) => Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)

shuffleMatchTraversable :: (Positive n, C a, Traversable f) => ConstValue (Vector n Word32) -> f (T n a) -> CodeGenFunction r (f (T n a))

insertTraversable :: (Positive n, C a, Traversable f, Applicative f) => Value Word32 -> f (T a) -> f (T n a) -> CodeGenFunction r (f (T n a))

extractTraversable :: (Positive n, C a, Traversable f) => Value Word32 -> f (T n a) -> CodeGenFunction r (f (T a))

class (IntegerConstant a, C a) => IntegerConstant a where

Methods

fromInteger' :: Positive n => Integer -> T n a

Instances

IntegerConstant Int16

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Positive n => Integer -> T n Int16

IntegerConstant Int32

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Positive n => Integer -> T n Int32

IntegerConstant Int64

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Positive n => Integer -> T n Int64

IntegerConstant Int8

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Positive n => Integer -> T n Int8

IntegerConstant Word16

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Positive n => Integer -> T n Word16

IntegerConstant Word32

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Positive n => Integer -> T n Word32

IntegerConstant Word64

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Positive n => Integer -> T n Word64

IntegerConstant Word8

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Positive n => Integer -> T n Word8

IntegerConstant Double

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Positive n => Integer -> T n Double

IntegerConstant Float

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Positive n => Integer -> T n Float

IntegerConstant Int

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Positive n => Integer -> T n Int

IntegerConstant Word

Defined in LLVM.Extra.Multi.Vector

Methods

fromInteger' :: Positive n => Integer -> T n Word

(Flags flags, MultiVector a, IntegerConstant a) => IntegerConstant (Number flags a)

Defined in LLVM.Extra.FastMath

Methods

fromInteger' :: Positive n => Integer -> T n (Number flags a)

class (RationalConstant a, IntegerConstant a) => RationalConstant a where

Methods

fromRational' :: Positive n => Rational -> T n a

Instances

RationalConstant Double

Defined in LLVM.Extra.Multi.Vector

Methods

fromRational' :: Positive n => Rational -> T n Double

RationalConstant Float

Defined in LLVM.Extra.Multi.Vector

Methods

fromRational' :: Positive n => Rational -> T n Float

(Flags flags, MultiVector a, RationalConstant a) => RationalConstant (Number flags a)

Defined in LLVM.Extra.FastMath

Methods

fromRational' :: Positive n => Rational -> T n (Number flags a)

class (Additive a, C a) => Additive a where

Methods

add :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

sub :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

neg :: Positive n => T n a -> CodeGenFunction r (T n a)

Instances

Additive Int16

Defined in LLVM.Extra.Multi.Vector

Methods

add :: Positive n => T n Int16 -> T n Int16 -> CodeGenFunction r (T n Int16)

sub :: Positive n => T n Int16 -> T n Int16 -> CodeGenFunction r (T n Int16)

neg :: Positive n => T n Int16 -> CodeGenFunction r (T n Int16)

Additive Int32

Defined in LLVM.Extra.Multi.Vector

Methods

add :: Positive n => T n Int32 -> T n Int32 -> CodeGenFunction r (T n Int32)

sub :: Positive n => T n Int32 -> T n Int32 -> CodeGenFunction r (T n Int32)

neg :: Positive n => T n Int32 -> CodeGenFunction r (T n Int32)

Additive Int64

Defined in LLVM.Extra.Multi.Vector

Methods

add :: Positive n => T n Int64 -> T n Int64 -> CodeGenFunction r (T n Int64)

sub :: Positive n => T n Int64 -> T n Int64 -> CodeGenFunction r (T n Int64)

neg :: Positive n => T n Int64 -> CodeGenFunction r (T n Int64)

Additive Int8

Defined in LLVM.Extra.Multi.Vector

Methods

add :: Positive n => T n Int8 -> T n Int8 -> CodeGenFunction r (T n Int8)

sub :: Positive n => T n Int8 -> T n Int8 -> CodeGenFunction r (T n Int8)

neg :: Positive n => T n Int8 -> CodeGenFunction r (T n Int8)

Additive Word16

Defined in LLVM.Extra.Multi.Vector

Methods

add :: Positive n => T n Word16 -> T n Word16 -> CodeGenFunction r (T n Word16)

sub :: Positive n => T n Word16 -> T n Word16 -> CodeGenFunction r (T n Word16)

neg :: Positive n => T n Word16 -> CodeGenFunction r (T n Word16)

Additive Word32

Defined in LLVM.Extra.Multi.Vector

Methods

add :: Positive n => T n Word32 -> T n Word32 -> CodeGenFunction r (T n Word32)

sub :: Positive n => T n Word32 -> T n Word32 -> CodeGenFunction r (T n Word32)

neg :: Positive n => T n Word32 -> CodeGenFunction r (T n Word32)

Additive Word64

Defined in LLVM.Extra.Multi.Vector

Methods

add :: Positive n => T n Word64 -> T n Word64 -> CodeGenFunction r (T n Word64)

sub :: Positive n => T n Word64 -> T n Word64 -> CodeGenFunction r (T n Word64)

neg :: Positive n => T n Word64 -> CodeGenFunction r (T n Word64)

Additive Word8

Defined in LLVM.Extra.Multi.Vector

Methods

add :: Positive n => T n Word8 -> T n Word8 -> CodeGenFunction r (T n Word8)

sub :: Positive n => T n Word8 -> T n Word8 -> CodeGenFunction r (T n Word8)

neg :: Positive n => T n Word8 -> CodeGenFunction r (T n Word8)

Additive Double

Defined in LLVM.Extra.Multi.Vector

Methods

add :: Positive n => T n Double -> T n Double -> CodeGenFunction r (T n Double)

sub :: Positive n => T n Double -> T n Double -> CodeGenFunction r (T n Double)

neg :: Positive n => T n Double -> CodeGenFunction r (T n Double)

Additive Float

Defined in LLVM.Extra.Multi.Vector

Methods

add :: Positive n => T n Float -> T n Float -> CodeGenFunction r (T n Float)

sub :: Positive n => T n Float -> T n Float -> CodeGenFunction r (T n Float)

neg :: Positive n => T n Float -> CodeGenFunction r (T n Float)

Additive Int

Defined in LLVM.Extra.Multi.Vector

Methods

add :: Positive n => T n Int -> T n Int -> CodeGenFunction r (T n Int)

sub :: Positive n => T n Int -> T n Int -> CodeGenFunction r (T n Int)

neg :: Positive n => T n Int -> CodeGenFunction r (T n Int)

Additive Word

Defined in LLVM.Extra.Multi.Vector

Methods

add :: Positive n => T n Word -> T n Word -> CodeGenFunction r (T n Word)

sub :: Positive n => T n Word -> T n Word -> CodeGenFunction r (T n Word)

neg :: Positive n => T n Word -> CodeGenFunction r (T n Word)

(Flags flags, MultiVector a, Additive a) => Additive (Number flags a)

Defined in LLVM.Extra.FastMath

Methods

add :: Positive n => T n (Number flags a) -> T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

sub :: Positive n => T n (Number flags a) -> T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

neg :: Positive n => T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

class (PseudoRing a, Additive a) => PseudoRing a where

Methods

mul :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

Instances

PseudoRing Double

Defined in LLVM.Extra.Multi.Vector

Methods

mul :: Positive n => T n Double -> T n Double -> CodeGenFunction r (T n Double)

PseudoRing Float

Defined in LLVM.Extra.Multi.Vector

Methods

mul :: Positive n => T n Float -> T n Float -> CodeGenFunction r (T n Float)

(Flags flags, MultiVector a, PseudoRing a) => PseudoRing (Number flags a)

Defined in LLVM.Extra.FastMath

Methods

mul :: Positive n => T n (Number flags a) -> T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

class (Field a, PseudoRing a) => Field a where

Methods

fdiv :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

Instances

Field Double

Defined in LLVM.Extra.Multi.Vector

Methods

fdiv :: Positive n => T n Double -> T n Double -> CodeGenFunction r (T n Double)

Field Float

Defined in LLVM.Extra.Multi.Vector

Methods

fdiv :: Positive n => T n Float -> T n Float -> CodeGenFunction r (T n Float)

(Flags flags, MultiVector a, Field a) => Field (Number flags a)

Defined in LLVM.Extra.FastMath

Methods

fdiv :: Positive n => T n (Number flags a) -> T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

scale :: (Positive n, PseudoRing a) => T a -> T n a -> CodeGenFunction r (T n a)

class (PseudoModule v, PseudoRing (Scalar v), Additive v) => PseudoModule v where

Methods

scaleMulti :: Positive n => T n (Scalar v) -> T n v -> CodeGenFunction r (T n v)

Instances

PseudoModule Double

Defined in LLVM.Extra.Multi.Vector

Methods

scaleMulti :: Positive n => T n (Scalar Double) -> T n Double -> CodeGenFunction r (T n Double)

PseudoModule Float

Defined in LLVM.Extra.Multi.Vector

Methods

scaleMulti :: Positive n => T n (Scalar Float) -> T n Float -> CodeGenFunction r (T n Float)

class (Real a, Additive a) => Real a where

Methods

min :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

max :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

abs :: Positive n => T n a -> CodeGenFunction r (T n a)

signum :: Positive n => T n a -> CodeGenFunction r (T n a)

Instances

Real Int16

Defined in LLVM.Extra.Multi.Vector

Methods

min :: Positive n => T n Int16 -> T n Int16 -> CodeGenFunction r (T n Int16)

max :: Positive n => T n Int16 -> T n Int16 -> CodeGenFunction r (T n Int16)

abs :: Positive n => T n Int16 -> CodeGenFunction r (T n Int16)

signum :: Positive n => T n Int16 -> CodeGenFunction r (T n Int16)

Real Int32

Defined in LLVM.Extra.Multi.Vector

Methods

min :: Positive n => T n Int32 -> T n Int32 -> CodeGenFunction r (T n Int32)

max :: Positive n => T n Int32 -> T n Int32 -> CodeGenFunction r (T n Int32)

abs :: Positive n => T n Int32 -> CodeGenFunction r (T n Int32)

signum :: Positive n => T n Int32 -> CodeGenFunction r (T n Int32)

Real Int64

Defined in LLVM.Extra.Multi.Vector

Methods

min :: Positive n => T n Int64 -> T n Int64 -> CodeGenFunction r (T n Int64)

max :: Positive n => T n Int64 -> T n Int64 -> CodeGenFunction r (T n Int64)

abs :: Positive n => T n Int64 -> CodeGenFunction r (T n Int64)

signum :: Positive n => T n Int64 -> CodeGenFunction r (T n Int64)

Real Int8

Defined in LLVM.Extra.Multi.Vector

Methods

min :: Positive n => T n Int8 -> T n Int8 -> CodeGenFunction r (T n Int8)

max :: Positive n => T n Int8 -> T n Int8 -> CodeGenFunction r (T n Int8)

abs :: Positive n => T n Int8 -> CodeGenFunction r (T n Int8)

signum :: Positive n => T n Int8 -> CodeGenFunction r (T n Int8)

Real Word16

Defined in LLVM.Extra.Multi.Vector

Methods

min :: Positive n => T n Word16 -> T n Word16 -> CodeGenFunction r (T n Word16)

max :: Positive n => T n Word16 -> T n Word16 -> CodeGenFunction r (T n Word16)

abs :: Positive n => T n Word16 -> CodeGenFunction r (T n Word16)

signum :: Positive n => T n Word16 -> CodeGenFunction r (T n Word16)

Real Word32

Defined in LLVM.Extra.Multi.Vector

Methods

min :: Positive n => T n Word32 -> T n Word32 -> CodeGenFunction r (T n Word32)

max :: Positive n => T n Word32 -> T n Word32 -> CodeGenFunction r (T n Word32)

abs :: Positive n => T n Word32 -> CodeGenFunction r (T n Word32)

signum :: Positive n => T n Word32 -> CodeGenFunction r (T n Word32)

Real Word64

Defined in LLVM.Extra.Multi.Vector

Methods

min :: Positive n => T n Word64 -> T n Word64 -> CodeGenFunction r (T n Word64)

max :: Positive n => T n Word64 -> T n Word64 -> CodeGenFunction r (T n Word64)

abs :: Positive n => T n Word64 -> CodeGenFunction r (T n Word64)

signum :: Positive n => T n Word64 -> CodeGenFunction r (T n Word64)

Real Word8

Defined in LLVM.Extra.Multi.Vector

Methods

min :: Positive n => T n Word8 -> T n Word8 -> CodeGenFunction r (T n Word8)

max :: Positive n => T n Word8 -> T n Word8 -> CodeGenFunction r (T n Word8)

abs :: Positive n => T n Word8 -> CodeGenFunction r (T n Word8)

signum :: Positive n => T n Word8 -> CodeGenFunction r (T n Word8)

Real Double

Defined in LLVM.Extra.Multi.Vector

Methods

min :: Positive n => T n Double -> T n Double -> CodeGenFunction r (T n Double)

max :: Positive n => T n Double -> T n Double -> CodeGenFunction r (T n Double)

abs :: Positive n => T n Double -> CodeGenFunction r (T n Double)

signum :: Positive n => T n Double -> CodeGenFunction r (T n Double)

Real Float

Defined in LLVM.Extra.Multi.Vector

Methods

min :: Positive n => T n Float -> T n Float -> CodeGenFunction r (T n Float)

max :: Positive n => T n Float -> T n Float -> CodeGenFunction r (T n Float)

abs :: Positive n => T n Float -> CodeGenFunction r (T n Float)

signum :: Positive n => T n Float -> CodeGenFunction r (T n Float)

Real Int

Defined in LLVM.Extra.Multi.Vector

Methods

min :: Positive n => T n Int -> T n Int -> CodeGenFunction r (T n Int)

max :: Positive n => T n Int -> T n Int -> CodeGenFunction r (T n Int)

abs :: Positive n => T n Int -> CodeGenFunction r (T n Int)

signum :: Positive n => T n Int -> CodeGenFunction r (T n Int)

Real Word

Defined in LLVM.Extra.Multi.Vector

Methods

min :: Positive n => T n Word -> T n Word -> CodeGenFunction r (T n Word)

max :: Positive n => T n Word -> T n Word -> CodeGenFunction r (T n Word)

abs :: Positive n => T n Word -> CodeGenFunction r (T n Word)

signum :: Positive n => T n Word -> CodeGenFunction r (T n Word)

(Flags flags, MultiVector a, Real a) => Real (Number flags a)

Defined in LLVM.Extra.FastMath

Methods

min :: Positive n => T n (Number flags a) -> T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

max :: Positive n => T n (Number flags a) -> T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

abs :: Positive n => T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

signum :: Positive n => T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

class (Fraction a, Real a) => Fraction a where

Methods

truncate :: Positive n => T n a -> CodeGenFunction r (T n a)

fraction :: Positive n => T n a -> CodeGenFunction r (T n a)

Instances

Fraction Double

Defined in LLVM.Extra.Multi.Vector

Methods

truncate :: Positive n => T n Double -> CodeGenFunction r (T n Double)

fraction :: Positive n => T n Double -> CodeGenFunction r (T n Double)

Fraction Float

Defined in LLVM.Extra.Multi.Vector

Methods

truncate :: Positive n => T n Float -> CodeGenFunction r (T n Float)

fraction :: Positive n => T n Float -> CodeGenFunction r (T n Float)

(Flags flags, MultiVector a, Fraction a) => Fraction (Number flags a)

Defined in LLVM.Extra.FastMath

Methods

truncate :: Positive n => T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

fraction :: Positive n => T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

class (Positive n, Repr n i ~ Value n ir, NativeInteger i ir, IsPrimitive ir, IsInteger ir) => NativeInteger n i ir

Instances

Positive n => NativeInteger n Int16 Int16

Defined in LLVM.Extra.Multi.Vector

Positive n => NativeInteger n Int32 Int32

Defined in LLVM.Extra.Multi.Vector

Positive n => NativeInteger n Int64 Int64

Defined in LLVM.Extra.Multi.Vector

Positive n => NativeInteger n Int8 Int8

Defined in LLVM.Extra.Multi.Vector

Positive n => NativeInteger n Word16 Word16

Defined in LLVM.Extra.Multi.Vector

Positive n => NativeInteger n Word32 Word32

Defined in LLVM.Extra.Multi.Vector

Positive n => NativeInteger n Word64 Word64

Defined in LLVM.Extra.Multi.Vector

Positive n => NativeInteger n Word8 Word8

Defined in LLVM.Extra.Multi.Vector

Positive n => NativeInteger n Int Int

Defined in LLVM.Extra.Multi.Vector

Positive n => NativeInteger n Word Word

Defined in LLVM.Extra.Multi.Vector

class (Positive n, Repr n a ~ Value n ar, NativeFloating a ar, IsPrimitive ar, IsFloating ar) => NativeFloating n a ar

Instances

Positive n => NativeFloating n Double Double

Defined in LLVM.Extra.Multi.Vector

Positive n => NativeFloating n Float Float

Defined in LLVM.Extra.Multi.Vector

fromIntegral :: (NativeInteger n i ir, NativeFloating n a ar) => T n i -> CodeGenFunction r (T n a)

class (Algebraic a, Field a) => Algebraic a where

Methods

sqrt :: Positive n => T n a -> CodeGenFunction r (T n a)

Instances

Algebraic Double

Defined in LLVM.Extra.Multi.Vector

Methods

sqrt :: Positive n => T n Double -> CodeGenFunction r (T n Double)

Algebraic Float

Defined in LLVM.Extra.Multi.Vector

Methods

sqrt :: Positive n => T n Float -> CodeGenFunction r (T n Float)

(Flags flags, MultiVector a, Algebraic a) => Algebraic (Number flags a)

Defined in LLVM.Extra.FastMath

Methods

sqrt :: Positive n => T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

class (Transcendental a, Algebraic a) => Transcendental a where

Methods

pi :: Positive n => CodeGenFunction r (T n a)

sin :: Positive n => T n a -> CodeGenFunction r (T n a)

cos :: Positive n => T n a -> CodeGenFunction r (T n a)

exp :: Positive n => T n a -> CodeGenFunction r (T n a)

log :: Positive n => T n a -> CodeGenFunction r (T n a)

pow :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

Instances

Transcendental Double

Defined in LLVM.Extra.Multi.Vector

Methods

pi :: Positive n => CodeGenFunction r (T n Double)

sin :: Positive n => T n Double -> CodeGenFunction r (T n Double)

cos :: Positive n => T n Double -> CodeGenFunction r (T n Double)

exp :: Positive n => T n Double -> CodeGenFunction r (T n Double)

log :: Positive n => T n Double -> CodeGenFunction r (T n Double)

pow :: Positive n => T n Double -> T n Double -> CodeGenFunction r (T n Double)

Transcendental Float

Defined in LLVM.Extra.Multi.Vector

Methods

pi :: Positive n => CodeGenFunction r (T n Float)

sin :: Positive n => T n Float -> CodeGenFunction r (T n Float)

cos :: Positive n => T n Float -> CodeGenFunction r (T n Float)

exp :: Positive n => T n Float -> CodeGenFunction r (T n Float)

log :: Positive n => T n Float -> CodeGenFunction r (T n Float)

pow :: Positive n => T n Float -> T n Float -> CodeGenFunction r (T n Float)

(Flags flags, MultiVector a, Transcendental a) => Transcendental (Number flags a)

Defined in LLVM.Extra.FastMath

Methods

pi :: Positive n => CodeGenFunction r (T n (Number flags a))

sin :: Positive n => T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

cos :: Positive n => T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

exp :: Positive n => T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

log :: Positive n => T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

pow :: Positive n => T n (Number flags a) -> T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

class (FloatingComparison a, Comparison a) => FloatingComparison a where

Methods

fcmp :: Positive n => FPPredicate -> T n a -> T n a -> CodeGenFunction r (T n Bool)

Instances

FloatingComparison Float

Defined in LLVM.Extra.Multi.Vector

Methods

fcmp :: Positive n => FPPredicate -> T n Float -> T n Float -> CodeGenFunction r (T n Bool)

(Flags flags, MultiVector a, FloatingComparison a) => FloatingComparison (Number flags a)

Defined in LLVM.Extra.FastMath

Methods

fcmp :: Positive n => FPPredicate -> T n (Number flags a) -> T n (Number flags a) -> CodeGenFunction r (T n Bool)

class (Select a, C a) => Select a where

Methods

select :: Positive n => T n Bool -> T n a -> T n a -> CodeGenFunction r (T n a)

Instances

Select Int16

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Int16 -> T n Int16 -> CodeGenFunction r (T n Int16)

Select Int32

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Int32 -> T n Int32 -> CodeGenFunction r (T n Int32)

Select Int64

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Int64 -> T n Int64 -> CodeGenFunction r (T n Int64)

Select Int8

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Int8 -> T n Int8 -> CodeGenFunction r (T n Int8)

Select Word16

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Word16 -> T n Word16 -> CodeGenFunction r (T n Word16)

Select Word32

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Word32 -> T n Word32 -> CodeGenFunction r (T n Word32)

Select Word64

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Word64 -> T n Word64 -> CodeGenFunction r (T n Word64)

Select Word8

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Word8 -> T n Word8 -> CodeGenFunction r (T n Word8)

Select Bool

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Bool -> T n Bool -> CodeGenFunction r (T n Bool)

Select Double

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Double -> T n Double -> CodeGenFunction r (T n Double)

Select Float

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Float -> T n Float -> CodeGenFunction r (T n Float)

Select Int

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Int -> T n Int -> CodeGenFunction r (T n Int)

Select Word

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n Word -> T n Word -> CodeGenFunction r (T n Word)

(Flags flags, MultiVector a, Select a) => Select (Number flags a)

Defined in LLVM.Extra.FastMath

Methods

select :: Positive n => T n Bool -> T n (Number flags a) -> T n (Number flags a) -> CodeGenFunction r (T n (Number flags a))

(Select a, Select b) => Select (a, b)

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n (a, b) -> T n (a, b) -> CodeGenFunction r (T n (a, b))

(Select a, Select b, Select c) => Select (a, b, c)

Defined in LLVM.Extra.Multi.Vector

Methods

select :: Positive n => T n Bool -> T n (a, b, c) -> T n (a, b, c) -> CodeGenFunction r (T n (a, b, c))

class (Comparison a, Real a) => Comparison a where

Methods

cmp :: Positive n => CmpPredicate -> T n a -> T n a -> CodeGenFunction r (T n Bool)

Instances

Comparison Int16

Defined in LLVM.Extra.Multi.Vector

Methods

cmp :: Positive n => CmpPredicate -> T n Int16 -> T n Int16 -> CodeGenFunction r (T n Bool)

Comparison Int32

Defined in LLVM.Extra.Multi.Vector

Methods

cmp :: Positive n => CmpPredicate -> T n Int32 -> T n Int32 -> CodeGenFunction r (T n Bool)

Comparison Int64

Defined in LLVM.Extra.Multi.Vector

Methods

cmp :: Positive n => CmpPredicate -> T n Int64 -> T n Int64 -> CodeGenFunction r (T n Bool)

Comparison Int8

Defined in LLVM.Extra.Multi.Vector

Methods

cmp :: Positive n => CmpPredicate -> T n Int8 -> T n Int8 -> CodeGenFunction r (T n Bool)

Comparison Word16

Defined in LLVM.Extra.Multi.Vector

Methods

cmp :: Positive n => CmpPredicate -> T n Word16 -> T n Word16 -> CodeGenFunction r (T n Bool)

Comparison Word32

Defined in LLVM.Extra.Multi.Vector

Methods

cmp :: Positive n => CmpPredicate -> T n Word32 -> T n Word32 -> CodeGenFunction r (T n Bool)

Comparison Word64

Defined in LLVM.Extra.Multi.Vector

Methods

cmp :: Positive n => CmpPredicate -> T n Word64 -> T n Word64 -> CodeGenFunction r (T n Bool)

Comparison Word8

Defined in LLVM.Extra.Multi.Vector

Methods

cmp :: Positive n => CmpPredicate -> T n Word8 -> T n Word8 -> CodeGenFunction r (T n Bool)

Comparison Double

Defined in LLVM.Extra.Multi.Vector

Methods

cmp :: Positive n => CmpPredicate -> T n Double -> T n Double -> CodeGenFunction r (T n Bool)

Comparison Float

Defined in LLVM.Extra.Multi.Vector

Methods

cmp :: Positive n => CmpPredicate -> T n Float -> T n Float -> CodeGenFunction r (T n Bool)

Comparison Int

Defined in LLVM.Extra.Multi.Vector

Methods

cmp :: Positive n => CmpPredicate -> T n Int -> T n Int -> CodeGenFunction r (T n Bool)

Comparison Word

Defined in LLVM.Extra.Multi.Vector

Methods

cmp :: Positive n => CmpPredicate -> T n Word -> T n Word -> CodeGenFunction r (T n Bool)

(Flags flags, MultiVector a, Comparison a) => Comparison (Number flags a)

Defined in LLVM.Extra.FastMath

Methods

cmp :: Positive n => CmpPredicate -> T n (Number flags a) -> T n (Number flags a) -> CodeGenFunction r (T n Bool)

class (Logic a, C a) => Logic a where

Methods

and :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

or :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

xor :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

inv :: Positive n => T n a -> CodeGenFunction r (T n a)

Instances

Logic Word16

Defined in LLVM.Extra.Multi.Vector

Methods

and :: Positive n => T n Word16 -> T n Word16 -> CodeGenFunction r (T n Word16)

or :: Positive n => T n Word16 -> T n Word16 -> CodeGenFunction r (T n Word16)

xor :: Positive n => T n Word16 -> T n Word16 -> CodeGenFunction r (T n Word16)

inv :: Positive n => T n Word16 -> CodeGenFunction r (T n Word16)

Logic Word32

Defined in LLVM.Extra.Multi.Vector

Methods

and :: Positive n => T n Word32 -> T n Word32 -> CodeGenFunction r (T n Word32)

or :: Positive n => T n Word32 -> T n Word32 -> CodeGenFunction r (T n Word32)

xor :: Positive n => T n Word32 -> T n Word32 -> CodeGenFunction r (T n Word32)

inv :: Positive n => T n Word32 -> CodeGenFunction r (T n Word32)

Logic Word64

Defined in LLVM.Extra.Multi.Vector

Methods

and :: Positive n => T n Word64 -> T n Word64 -> CodeGenFunction r (T n Word64)

or :: Positive n => T n Word64 -> T n Word64 -> CodeGenFunction r (T n Word64)

xor :: Positive n => T n Word64 -> T n Word64 -> CodeGenFunction r (T n Word64)

inv :: Positive n => T n Word64 -> CodeGenFunction r (T n Word64)

Logic Word8

Defined in LLVM.Extra.Multi.Vector

Methods

and :: Positive n => T n Word8 -> T n Word8 -> CodeGenFunction r (T n Word8)

or :: Positive n => T n Word8 -> T n Word8 -> CodeGenFunction r (T n Word8)

xor :: Positive n => T n Word8 -> T n Word8 -> CodeGenFunction r (T n Word8)

inv :: Positive n => T n Word8 -> CodeGenFunction r (T n Word8)

Logic Bool

Defined in LLVM.Extra.Multi.Vector

Methods

and :: Positive n => T n Bool -> T n Bool -> CodeGenFunction r (T n Bool)

or :: Positive n => T n Bool -> T n Bool -> CodeGenFunction r (T n Bool)

xor :: Positive n => T n Bool -> T n Bool -> CodeGenFunction r (T n Bool)

inv :: Positive n => T n Bool -> CodeGenFunction r (T n Bool)

class (BitShift a, C a) => BitShift a where

Methods

shl :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

shr :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

Instances

BitShift Int16

Defined in LLVM.Extra.Multi.Vector

Methods

shl :: Positive n => T n Int16 -> T n Int16 -> CodeGenFunction r (T n Int16)

shr :: Positive n => T n Int16 -> T n Int16 -> CodeGenFunction r (T n Int16)

BitShift Int32

Defined in LLVM.Extra.Multi.Vector

Methods

shl :: Positive n => T n Int32 -> T n Int32 -> CodeGenFunction r (T n Int32)

shr :: Positive n => T n Int32 -> T n Int32 -> CodeGenFunction r (T n Int32)

BitShift Int64

Defined in LLVM.Extra.Multi.Vector

Methods

shl :: Positive n => T n Int64 -> T n Int64 -> CodeGenFunction r (T n Int64)

shr :: Positive n => T n Int64 -> T n Int64 -> CodeGenFunction r (T n Int64)

BitShift Int8

Defined in LLVM.Extra.Multi.Vector

Methods

shl :: Positive n => T n Int8 -> T n Int8 -> CodeGenFunction r (T n Int8)

shr :: Positive n => T n Int8 -> T n Int8 -> CodeGenFunction r (T n Int8)

BitShift Word16

Defined in LLVM.Extra.Multi.Vector

Methods

shl :: Positive n => T n Word16 -> T n Word16 -> CodeGenFunction r (T n Word16)

shr :: Positive n => T n Word16 -> T n Word16 -> CodeGenFunction r (T n Word16)

BitShift Word32

Defined in LLVM.Extra.Multi.Vector

Methods

shl :: Positive n => T n Word32 -> T n Word32 -> CodeGenFunction r (T n Word32)

shr :: Positive n => T n Word32 -> T n Word32 -> CodeGenFunction r (T n Word32)

BitShift Word64

Defined in LLVM.Extra.Multi.Vector

Methods

shl :: Positive n => T n Word64 -> T n Word64 -> CodeGenFunction r (T n Word64)

shr :: Positive n => T n Word64 -> T n Word64 -> CodeGenFunction r (T n Word64)

BitShift Word8

Defined in LLVM.Extra.Multi.Vector

Methods

shl :: Positive n => T n Word8 -> T n Word8 -> CodeGenFunction r (T n Word8)

shr :: Positive n => T n Word8 -> T n Word8 -> CodeGenFunction r (T n Word8)

BitShift Int

Defined in LLVM.Extra.Multi.Vector

Methods

shl :: Positive n => T n Int -> T n Int -> CodeGenFunction r (T n Int)

shr :: Positive n => T n Int -> T n Int -> CodeGenFunction r (T n Int)

BitShift Word

Defined in LLVM.Extra.Multi.Vector

Methods

shl :: Positive n => T n Word -> T n Word -> CodeGenFunction r (T n Word)

shr :: Positive n => T n Word -> T n Word -> CodeGenFunction r (T n Word)