{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE UndecidableInstances #-}
module LLVM.Extra.Storable.Private where

import qualified LLVM.Extra.Tuple as Tuple
import qualified LLVM.Extra.ArithmeticPrivate as A
import qualified LLVM.Util.Proxy as LP
import qualified LLVM.Core as LLVM
import LLVM.Core (CodeGenFunction, Value)

import qualified Type.Data.Num.Decimal as TypeNum

import qualified Control.Monad.Trans.Class as MT
import qualified Control.Monad.Trans.Reader as MR
import qualified Control.Monad.Trans.State as MS
import qualified Control.Applicative.HT as App
import qualified Control.Functor.HT as FuncHT
import Control.Monad (foldM, replicateM, replicateM_, (<=<))
import Control.Applicative (Applicative, pure)

import qualified Foreign.Storable.Record.Tuple as StoreTuple
import qualified Foreign.Storable as Store
import Foreign.Storable.FixedArray (roundUp)
import Foreign.Ptr (Ptr)

import qualified Data.NonEmpty.Class as NonEmptyC
import qualified Data.Traversable as Trav
import qualified Data.Foldable as Fold
import Data.Orphans ()
import Data.Complex (Complex)
import Data.Word (Word8, Word16, Word32, Word64, Word)
import Data.Int  (Int8,  Int16,  Int32,  Int64)
import Data.Bool8 (Bool8)



class
   (Store.Storable a, Tuple.Value a,
    Tuple.Phi (Tuple.ValueOf a), Tuple.Undefined (Tuple.ValueOf a)) =>
      C a where

   {-
   Not all Storable types have a compatible LLVM type,
   or even more, one LLVM type that is compatible on all platforms.
   -}
   load :: Value (Ptr a) -> CodeGenFunction r (Tuple.ValueOf a)
   store :: Tuple.ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()

storeNext ::
   (C a, Tuple.ValueOf a ~ al, Value (Ptr a) ~ ptr) =>
   al -> ptr -> CodeGenFunction r ptr
storeNext :: forall a al ptr r.
(C a, ValueOf a ~ al, Value (Ptr a) ~ ptr) =>
al -> ptr -> CodeGenFunction r ptr
storeNext al
a ptr
ptr  =  ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
forall r. ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
forall a r.
C a =>
ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
store al
ValueOf a
a ptr
Value (Ptr a)
ptr CodeGenFunction r ()
-> CodeGenFunction r ptr -> CodeGenFunction r ptr
forall a b.
CodeGenFunction r a -> CodeGenFunction r b -> CodeGenFunction r b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ptr -> CodeGenFunction r ptr
forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
ptr -> CodeGenFunction r ptr
incrementPtr ptr
ptr

modify ::
   (C a, Tuple.ValueOf a ~ al) =>
   (al -> CodeGenFunction r al) ->
   Value (Ptr a) -> CodeGenFunction r ()
modify :: forall a al r.
(C a, ValueOf a ~ al) =>
(al -> CodeGenFunction r al)
-> Value (Ptr a) -> CodeGenFunction r ()
modify al -> CodeGenFunction r al
f Value (Ptr a)
ptr  =  (al -> Value (Ptr a) -> CodeGenFunction r ())
-> Value (Ptr a) -> al -> CodeGenFunction r ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip al -> Value (Ptr a) -> CodeGenFunction r ()
ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
forall r. ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
forall a r.
C a =>
ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
store Value (Ptr a)
ptr (al -> CodeGenFunction r ())
-> CodeGenFunction r al -> CodeGenFunction r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< al -> CodeGenFunction r al
f (al -> CodeGenFunction r al)
-> CodeGenFunction r al -> CodeGenFunction r al
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr a) -> CodeGenFunction r (ValueOf a)
forall r. Value (Ptr a) -> CodeGenFunction r (ValueOf a)
forall a r. C a => Value (Ptr a) -> CodeGenFunction r (ValueOf a)
load Value (Ptr a)
ptr


loadPrimitive ::
   (LLVM.Storable a) => Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive :: forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive Value (Ptr a)
ptr = Value (Ptr a) -> CodeGenFunction r (Value a)
forall a r.
IsType a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
LLVM.load (Value (Ptr a) -> CodeGenFunction r (Value a))
-> CodeGenFunction r (Value (Ptr a)) -> CodeGenFunction r (Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
forall (value :: * -> *) a b r.
(ValueCons value, IsSized a, IsSized b, SizeOf a ~ SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.bitcast Value (Ptr a)
ptr

storePrimitive ::
   (LLVM.Storable a) => Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive :: forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive Value a
a Value (Ptr a)
ptr = Value a -> Value (Ptr a) -> CodeGenFunction r ()
forall a r.
IsType a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
LLVM.store Value a
a (Value (Ptr a) -> CodeGenFunction r ())
-> CodeGenFunction r (Value (Ptr a)) -> CodeGenFunction r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
forall (value :: * -> *) a b r.
(ValueCons value, IsSized a, IsSized b, SizeOf a ~ SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.bitcast Value (Ptr a)
ptr

instance C Float where
   load :: forall r. Value (Ptr Float) -> CodeGenFunction r (ValueOf Float)
load = Value (Ptr Float) -> CodeGenFunction r (Value Float)
Value (Ptr Float) -> CodeGenFunction r (ValueOf Float)
forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive; store :: forall r.
ValueOf Float -> Value (Ptr Float) -> CodeGenFunction r ()
store = Value Float -> Value (Ptr Float) -> CodeGenFunction r ()
ValueOf Float -> Value (Ptr Float) -> CodeGenFunction r ()
forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Double where
   load :: forall r. Value (Ptr Double) -> CodeGenFunction r (ValueOf Double)
load = Value (Ptr Double) -> CodeGenFunction r (Value Double)
Value (Ptr Double) -> CodeGenFunction r (ValueOf Double)
forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive; store :: forall r.
ValueOf Double -> Value (Ptr Double) -> CodeGenFunction r ()
store = Value Double -> Value (Ptr Double) -> CodeGenFunction r ()
ValueOf Double -> Value (Ptr Double) -> CodeGenFunction r ()
forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Word where
   load :: forall r. Value (Ptr Word) -> CodeGenFunction r (ValueOf Word)
load = Value (Ptr Word) -> CodeGenFunction r (Value Word)
Value (Ptr Word) -> CodeGenFunction r (ValueOf Word)
forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive; store :: forall r. ValueOf Word -> Value (Ptr Word) -> CodeGenFunction r ()
store = Value Word -> Value (Ptr Word) -> CodeGenFunction r ()
ValueOf Word -> Value (Ptr Word) -> CodeGenFunction r ()
forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Word8 where
   load :: forall r. Value (Ptr Word8) -> CodeGenFunction r (ValueOf Word8)
load = Value (Ptr Word8) -> CodeGenFunction r (Value Word8)
Value (Ptr Word8) -> CodeGenFunction r (ValueOf Word8)
forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive; store :: forall r.
ValueOf Word8 -> Value (Ptr Word8) -> CodeGenFunction r ()
store = Value Word8 -> Value (Ptr Word8) -> CodeGenFunction r ()
ValueOf Word8 -> Value (Ptr Word8) -> CodeGenFunction r ()
forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Word16 where
   load :: forall r. Value (Ptr Word16) -> CodeGenFunction r (ValueOf Word16)
load = Value (Ptr Word16) -> CodeGenFunction r (Value Word16)
Value (Ptr Word16) -> CodeGenFunction r (ValueOf Word16)
forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive; store :: forall r.
ValueOf Word16 -> Value (Ptr Word16) -> CodeGenFunction r ()
store = Value Word16 -> Value (Ptr Word16) -> CodeGenFunction r ()
ValueOf Word16 -> Value (Ptr Word16) -> CodeGenFunction r ()
forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Word32 where
   load :: forall r. Value (Ptr Word32) -> CodeGenFunction r (ValueOf Word32)
load = Value (Ptr Word32) -> CodeGenFunction r (Value Word32)
Value (Ptr Word32) -> CodeGenFunction r (ValueOf Word32)
forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive; store :: forall r.
ValueOf Word32 -> Value (Ptr Word32) -> CodeGenFunction r ()
store = Value Word32 -> Value (Ptr Word32) -> CodeGenFunction r ()
ValueOf Word32 -> Value (Ptr Word32) -> CodeGenFunction r ()
forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Word64 where
   load :: forall r. Value (Ptr Word64) -> CodeGenFunction r (ValueOf Word64)
load = Value (Ptr Word64) -> CodeGenFunction r (Value Word64)
Value (Ptr Word64) -> CodeGenFunction r (ValueOf Word64)
forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive; store :: forall r.
ValueOf Word64 -> Value (Ptr Word64) -> CodeGenFunction r ()
store = Value Word64 -> Value (Ptr Word64) -> CodeGenFunction r ()
ValueOf Word64 -> Value (Ptr Word64) -> CodeGenFunction r ()
forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Int where
   load :: forall r. Value (Ptr Int) -> CodeGenFunction r (ValueOf Int)
load = Value (Ptr Int) -> CodeGenFunction r (Value Int)
Value (Ptr Int) -> CodeGenFunction r (ValueOf Int)
forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive; store :: forall r. ValueOf Int -> Value (Ptr Int) -> CodeGenFunction r ()
store = Value Int -> Value (Ptr Int) -> CodeGenFunction r ()
ValueOf Int -> Value (Ptr Int) -> CodeGenFunction r ()
forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Int8 where
   load :: forall r. Value (Ptr Int8) -> CodeGenFunction r (ValueOf Int8)
load = Value (Ptr Int8) -> CodeGenFunction r (Value Int8)
Value (Ptr Int8) -> CodeGenFunction r (ValueOf Int8)
forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive; store :: forall r. ValueOf Int8 -> Value (Ptr Int8) -> CodeGenFunction r ()
store = Value Int8 -> Value (Ptr Int8) -> CodeGenFunction r ()
ValueOf Int8 -> Value (Ptr Int8) -> CodeGenFunction r ()
forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Int16 where
   load :: forall r. Value (Ptr Int16) -> CodeGenFunction r (ValueOf Int16)
load = Value (Ptr Int16) -> CodeGenFunction r (Value Int16)
Value (Ptr Int16) -> CodeGenFunction r (ValueOf Int16)
forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive; store :: forall r.
ValueOf Int16 -> Value (Ptr Int16) -> CodeGenFunction r ()
store = Value Int16 -> Value (Ptr Int16) -> CodeGenFunction r ()
ValueOf Int16 -> Value (Ptr Int16) -> CodeGenFunction r ()
forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Int32 where
   load :: forall r. Value (Ptr Int32) -> CodeGenFunction r (ValueOf Int32)
load = Value (Ptr Int32) -> CodeGenFunction r (Value Int32)
Value (Ptr Int32) -> CodeGenFunction r (ValueOf Int32)
forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive; store :: forall r.
ValueOf Int32 -> Value (Ptr Int32) -> CodeGenFunction r ()
store = Value Int32 -> Value (Ptr Int32) -> CodeGenFunction r ()
ValueOf Int32 -> Value (Ptr Int32) -> CodeGenFunction r ()
forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Int64 where
   load :: forall r. Value (Ptr Int64) -> CodeGenFunction r (ValueOf Int64)
load = Value (Ptr Int64) -> CodeGenFunction r (Value Int64)
Value (Ptr Int64) -> CodeGenFunction r (ValueOf Int64)
forall a r.
Storable a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
loadPrimitive; store :: forall r.
ValueOf Int64 -> Value (Ptr Int64) -> CodeGenFunction r ()
store = Value Int64 -> Value (Ptr Int64) -> CodeGenFunction r ()
ValueOf Int64 -> Value (Ptr Int64) -> CodeGenFunction r ()
forall a r.
Storable a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

{- |
Not very efficient implementation
because we want to adapt to @sizeOf Bool@ dynamically.
Unfortunately, LLVM-9's optimizer does not recognize the instruction pattern.
Better use 'Bool8' for booleans.
-}
instance C Bool where
   load :: forall r. Value (Ptr Bool) -> CodeGenFunction r (ValueOf Bool)
load Value (Ptr Bool)
ptr = do
      BytePtr
bytePtr <- Value (Ptr Bool) -> CodeGenFunction r BytePtr
forall a r. Value (Ptr a) -> CodeGenFunction r BytePtr
castToBytePtr Value (Ptr Bool)
ptr
      [Value Word8]
bytes <-
         (StateT BytePtr (CodeGenFunction r) [Value Word8]
 -> BytePtr -> CodeGenFunction r [Value Word8])
-> BytePtr
-> StateT BytePtr (CodeGenFunction r) [Value Word8]
-> CodeGenFunction r [Value Word8]
forall a b c. (a -> b -> c) -> b -> a -> c
flip StateT BytePtr (CodeGenFunction r) [Value Word8]
-> BytePtr -> CodeGenFunction r [Value Word8]
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
MS.evalStateT BytePtr
bytePtr (StateT BytePtr (CodeGenFunction r) [Value Word8]
 -> CodeGenFunction r [Value Word8])
-> StateT BytePtr (CodeGenFunction r) [Value Word8]
-> CodeGenFunction r [Value Word8]
forall a b. (a -> b) -> a -> b
$
            Int
-> StateT BytePtr (CodeGenFunction r) (Value Word8)
-> StateT BytePtr (CodeGenFunction r) [Value Word8]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM (Bool -> Int
forall a. Storable a => a -> Int
Store.sizeOf (Bool
False :: Bool))
               (CodeGenFunction r (Value Word8)
-> StateT BytePtr (CodeGenFunction r) (Value Word8)
forall (m :: * -> *) a. Monad m => m a -> StateT BytePtr m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r (Value Word8)
 -> StateT BytePtr (CodeGenFunction r) (Value Word8))
-> (BytePtr -> CodeGenFunction r (Value Word8))
-> BytePtr
-> StateT BytePtr (CodeGenFunction r) (Value Word8)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BytePtr -> CodeGenFunction r (Value Word8)
forall a r.
IsType a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
LLVM.load (BytePtr -> StateT BytePtr (CodeGenFunction r) (Value Word8))
-> StateT BytePtr (CodeGenFunction r) BytePtr
-> StateT BytePtr (CodeGenFunction r) (Value Word8)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< StateT BytePtr (CodeGenFunction r) BytePtr
forall r. StateT BytePtr (CodeGenFunction r) BytePtr
incPtrState)
      let zero :: Value Word8
zero = Word8 -> Value Word8
forall a. IsConst a => a -> Value a
LLVM.valueOf Word8
0
      Value Word8
mask <- (Value Word8 -> Value Word8 -> CodeGenFunction r (Value Word8))
-> Value Word8 -> [Value Word8] -> CodeGenFunction r (Value Word8)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM Value Word8 -> Value Word8 -> CodeGenFunction r (Value Word8)
forall a r.
IsInteger a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.or Value Word8
zero [Value Word8]
bytes
      CmpPredicate
-> Value Word8 -> Value Word8 -> CodeGenFunction r (Value Bool)
forall a b r.
(CmpRet a, CmpResult a ~ b) =>
CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.cmp CmpPredicate
LLVM.CmpNE Value Word8
mask Value Word8
zero
   store :: forall r. ValueOf Bool -> Value (Ptr Bool) -> CodeGenFunction r ()
store ValueOf Bool
b Value (Ptr Bool)
ptr = do
      BytePtr
bytePtr <- Value (Ptr Bool) -> CodeGenFunction r BytePtr
forall a r. Value (Ptr a) -> CodeGenFunction r BytePtr
castToBytePtr Value (Ptr Bool)
ptr
      Value Word8
byte <- Value Bool -> CodeGenFunction r (Value Word8)
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsInteger b, ShapeOf a ~ ShapeOf b,
 IsSized a, IsSized b, SizeOf a :<: SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.sext Value Bool
ValueOf Bool
b
      (StateT BytePtr (CodeGenFunction r) ()
 -> BytePtr -> CodeGenFunction r ())
-> BytePtr
-> StateT BytePtr (CodeGenFunction r) ()
-> CodeGenFunction r ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip StateT BytePtr (CodeGenFunction r) ()
-> BytePtr -> CodeGenFunction r ()
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
MS.evalStateT BytePtr
bytePtr (StateT BytePtr (CodeGenFunction r) () -> CodeGenFunction r ())
-> StateT BytePtr (CodeGenFunction r) () -> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$
         Int
-> StateT BytePtr (CodeGenFunction r) ()
-> StateT BytePtr (CodeGenFunction r) ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ (Bool -> Int
forall a. Storable a => a -> Int
Store.sizeOf (Bool
False :: Bool))
            (CodeGenFunction r () -> StateT BytePtr (CodeGenFunction r) ()
forall (m :: * -> *) a. Monad m => m a -> StateT BytePtr m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r () -> StateT BytePtr (CodeGenFunction r) ())
-> (BytePtr -> CodeGenFunction r ())
-> BytePtr
-> StateT BytePtr (CodeGenFunction r) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value Word8 -> BytePtr -> CodeGenFunction r ()
forall a r.
IsType a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
LLVM.store Value Word8
byte (BytePtr -> StateT BytePtr (CodeGenFunction r) ())
-> StateT BytePtr (CodeGenFunction r) BytePtr
-> StateT BytePtr (CodeGenFunction r) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< StateT BytePtr (CodeGenFunction r) BytePtr
forall r. StateT BytePtr (CodeGenFunction r) BytePtr
incPtrState)

incPtrState :: MS.StateT BytePtr (CodeGenFunction r) BytePtr
incPtrState :: forall r. StateT BytePtr (CodeGenFunction r) BytePtr
incPtrState = (BytePtr -> CodeGenFunction r BytePtr)
-> StateT BytePtr (CodeGenFunction r) BytePtr
forall (m :: * -> *) a. Monad m => (a -> m a) -> StateT a m a
update BytePtr -> CodeGenFunction r BytePtr
forall a r.
IsType a =>
Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
A.advanceArrayElementPtr

instance C Bool8 where
   load :: forall r. Value (Ptr Bool8) -> CodeGenFunction r (ValueOf Bool8)
load Value (Ptr Bool8)
ptr =
      CmpPredicate
-> Value Word8 -> Value Word8 -> CodeGenFunction r (Value Bool)
forall a b r.
(CmpRet a, CmpResult a ~ b) =>
CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.cmp CmpPredicate
LLVM.CmpNE (Word8 -> Value Word8
forall a. IsConst a => a -> Value a
LLVM.valueOf Word8
0) (Value Word8 -> CodeGenFunction r (Value Bool))
-> CodeGenFunction r (Value Word8)
-> CodeGenFunction r (Value Bool)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< BytePtr -> CodeGenFunction r (Value Word8)
forall a r.
IsType a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
LLVM.load (BytePtr -> CodeGenFunction r (Value Word8))
-> CodeGenFunction r BytePtr -> CodeGenFunction r (Value Word8)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr Bool8) -> CodeGenFunction r BytePtr
forall a r. Value (Ptr a) -> CodeGenFunction r BytePtr
castToBytePtr Value (Ptr Bool8)
ptr
   store :: forall r.
ValueOf Bool8 -> Value (Ptr Bool8) -> CodeGenFunction r ()
store ValueOf Bool8
b Value (Ptr Bool8)
ptr = do
      Value Word8
byte <- Value Bool -> CodeGenFunction r (Value Word8)
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsInteger b, ShapeOf a ~ ShapeOf b,
 IsSized a, IsSized b, SizeOf a :<: SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.zext Value Bool
ValueOf Bool8
b
      Value Word8 -> BytePtr -> CodeGenFunction r ()
forall a r.
IsType a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
LLVM.store Value Word8
byte (BytePtr -> CodeGenFunction r ())
-> CodeGenFunction r BytePtr -> CodeGenFunction r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr Bool8) -> CodeGenFunction r BytePtr
forall a r. Value (Ptr a) -> CodeGenFunction r BytePtr
castToBytePtr Value (Ptr Bool8)
ptr

instance (C a) => C (Complex a) where
   load :: forall r.
Value (Ptr (Complex a)) -> CodeGenFunction r (ValueOf (Complex a))
load = Value (Ptr (Complex a)) -> CodeGenFunction r (Complex (ValueOf a))
Value (Ptr (Complex a)) -> CodeGenFunction r (ValueOf (Complex a))
forall (f :: * -> *) a al r.
(Applicative f, Traversable f, C a, ValueOf a ~ al) =>
Value (Ptr (f a)) -> CodeGenFunction r (f al)
loadApplicative; store :: forall r.
ValueOf (Complex a)
-> Value (Ptr (Complex a)) -> CodeGenFunction r ()
store = Complex (ValueOf a)
-> Value (Ptr (Complex a)) -> CodeGenFunction r ()
ValueOf (Complex a)
-> Value (Ptr (Complex a)) -> CodeGenFunction r ()
forall (f :: * -> *) a al r.
(Foldable f, C a, ValueOf a ~ al) =>
f al -> Value (Ptr (f a)) -> CodeGenFunction r ()
storeFoldable



instance (Tuple tuple) => C (StoreTuple.Tuple tuple) where
   load :: forall r.
Value (Ptr (Tuple tuple))
-> CodeGenFunction r (ValueOf (Tuple tuple))
load = Value (Ptr (Tuple tuple)) -> CodeGenFunction r (ValueOf tuple)
Value (Ptr (Tuple tuple))
-> CodeGenFunction r (ValueOf (Tuple tuple))
forall r.
Value (Ptr (Tuple tuple)) -> CodeGenFunction r (ValueOf tuple)
forall tuple r.
Tuple tuple =>
Value (Ptr (Tuple tuple)) -> CodeGenFunction r (ValueOf tuple)
loadTuple
   store :: forall r.
ValueOf (Tuple tuple)
-> Value (Ptr (Tuple tuple)) -> CodeGenFunction r ()
store = ValueOf tuple -> Value (Ptr (Tuple tuple)) -> CodeGenFunction r ()
ValueOf (Tuple tuple)
-> Value (Ptr (Tuple tuple)) -> CodeGenFunction r ()
forall r.
ValueOf tuple -> Value (Ptr (Tuple tuple)) -> CodeGenFunction r ()
forall tuple r.
Tuple tuple =>
ValueOf tuple -> Value (Ptr (Tuple tuple)) -> CodeGenFunction r ()
storeTuple

class
   (StoreTuple.Storable tuple, Tuple.Value tuple,
    Tuple.Phi (Tuple.ValueOf tuple), Tuple.Undefined (Tuple.ValueOf tuple)) =>
      Tuple tuple where
   loadTuple ::
      Value (Ptr (StoreTuple.Tuple tuple)) ->
      CodeGenFunction r (Tuple.ValueOf tuple)
   storeTuple ::
      Tuple.ValueOf tuple ->
      Value (Ptr (StoreTuple.Tuple tuple)) ->
      CodeGenFunction r ()

instance (C a, C b) => Tuple (a,b) where
   loadTuple :: forall r.
Value (Ptr (Tuple (a, b))) -> CodeGenFunction r (ValueOf (a, b))
loadTuple Value (Ptr (Tuple (a, b)))
ptr =
      Value (Ptr (Tuple (a, b)))
-> ReaderT
     BytePtr (StateT Int (CodeGenFunction r)) (ValueOf (a, b))
-> CodeGenFunction r (ValueOf (a, b))
forall a r c.
Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
-> CodeGenFunction r c
runElements Value (Ptr (Tuple (a, b)))
ptr (ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf (a, b))
 -> CodeGenFunction r (ValueOf (a, b)))
-> ReaderT
     BytePtr (StateT Int (CodeGenFunction r)) (ValueOf (a, b))
-> CodeGenFunction r (ValueOf (a, b))
forall a b. (a -> b) -> a -> b
$
         (Proxy a
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a),
 Proxy b
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf b))
-> (Proxy a, Proxy b)
-> ReaderT
     BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a, ValueOf b)
forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c, b -> f d) -> (a, b) -> f (c, d)
App.mapPair (Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a)
forall a r.
C a =>
Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a)
loadElement, Proxy b
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf b)
forall a r.
C a =>
Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a)
loadElement) ((Proxy a, Proxy b)
 -> ReaderT
      BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a, ValueOf b))
-> (Proxy a, Proxy b)
-> ReaderT
     BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a, ValueOf b)
forall a b. (a -> b) -> a -> b
$
         Proxy (a, b) -> (Proxy a, Proxy b)
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
FuncHT.unzip (Proxy (a, b) -> (Proxy a, Proxy b))
-> Proxy (a, b) -> (Proxy a, Proxy b)
forall a b. (a -> b) -> a -> b
$ Value (Ptr (Tuple (a, b))) -> Proxy (a, b)
forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 Value (Ptr (Tuple (a, b)))
ptr
   storeTuple :: forall r.
ValueOf (a, b)
-> Value (Ptr (Tuple (a, b))) -> CodeGenFunction r ()
storeTuple (ValueOf a
a,ValueOf b
b) Value (Ptr (Tuple (a, b)))
ptr =
      case Proxy (a, b) -> (Proxy a, Proxy b)
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
FuncHT.unzip (Proxy (a, b) -> (Proxy a, Proxy b))
-> Proxy (a, b) -> (Proxy a, Proxy b)
forall a b. (a -> b) -> a -> b
$ Value (Ptr (Tuple (a, b))) -> Proxy (a, b)
forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 Value (Ptr (Tuple (a, b)))
ptr of
         (Proxy a
pa,Proxy b
pb) -> Value (Ptr (Tuple (a, b)))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> CodeGenFunction r ()
forall a r c.
Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
-> CodeGenFunction r c
runElements Value (Ptr (Tuple (a, b)))
ptr (ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
 -> CodeGenFunction r ())
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$ Proxy a
-> ValueOf a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a r.
C a =>
Proxy a
-> ValueOf a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
storeElement Proxy a
pa ValueOf a
a ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a b.
ReaderT BytePtr (StateT Int (CodeGenFunction r)) a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Proxy b
-> ValueOf b -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a r.
C a =>
Proxy a
-> ValueOf a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
storeElement Proxy b
pb ValueOf b
b

instance (C a, C b, C c) => Tuple (a,b,c) where
   loadTuple :: forall r.
Value (Ptr (Tuple (a, b, c)))
-> CodeGenFunction r (ValueOf (a, b, c))
loadTuple Value (Ptr (Tuple (a, b, c)))
ptr =
      Value (Ptr (Tuple (a, b, c)))
-> ReaderT
     BytePtr (StateT Int (CodeGenFunction r)) (ValueOf (a, b, c))
-> CodeGenFunction r (ValueOf (a, b, c))
forall a r c.
Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
-> CodeGenFunction r c
runElements Value (Ptr (Tuple (a, b, c)))
ptr (ReaderT
   BytePtr (StateT Int (CodeGenFunction r)) (ValueOf (a, b, c))
 -> CodeGenFunction r (ValueOf (a, b, c)))
-> ReaderT
     BytePtr (StateT Int (CodeGenFunction r)) (ValueOf (a, b, c))
-> CodeGenFunction r (ValueOf (a, b, c))
forall a b. (a -> b) -> a -> b
$
         (Proxy a
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a),
 Proxy b
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf b),
 Proxy c
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf c))
-> (Proxy a, Proxy b, Proxy c)
-> ReaderT
     BytePtr
     (StateT Int (CodeGenFunction r))
     (ValueOf a, ValueOf b, ValueOf c)
forall (m :: * -> *) a d b e c f.
Applicative m =>
(a -> m d, b -> m e, c -> m f) -> (a, b, c) -> m (d, e, f)
App.mapTriple (Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a)
forall a r.
C a =>
Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a)
loadElement, Proxy b
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf b)
forall a r.
C a =>
Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a)
loadElement, Proxy c
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf c)
forall a r.
C a =>
Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a)
loadElement) ((Proxy a, Proxy b, Proxy c)
 -> ReaderT
      BytePtr
      (StateT Int (CodeGenFunction r))
      (ValueOf a, ValueOf b, ValueOf c))
-> (Proxy a, Proxy b, Proxy c)
-> ReaderT
     BytePtr
     (StateT Int (CodeGenFunction r))
     (ValueOf a, ValueOf b, ValueOf c)
forall a b. (a -> b) -> a -> b
$
         Proxy (a, b, c) -> (Proxy a, Proxy b, Proxy c)
forall (f :: * -> *) a b c.
Functor f =>
f (a, b, c) -> (f a, f b, f c)
FuncHT.unzip3 (Proxy (a, b, c) -> (Proxy a, Proxy b, Proxy c))
-> Proxy (a, b, c) -> (Proxy a, Proxy b, Proxy c)
forall a b. (a -> b) -> a -> b
$ Value (Ptr (Tuple (a, b, c))) -> Proxy (a, b, c)
forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 Value (Ptr (Tuple (a, b, c)))
ptr
   storeTuple :: forall r.
ValueOf (a, b, c)
-> Value (Ptr (Tuple (a, b, c))) -> CodeGenFunction r ()
storeTuple (ValueOf a
a,ValueOf b
b,ValueOf c
c) Value (Ptr (Tuple (a, b, c)))
ptr =
      case Proxy (a, b, c) -> (Proxy a, Proxy b, Proxy c)
forall (f :: * -> *) a b c.
Functor f =>
f (a, b, c) -> (f a, f b, f c)
FuncHT.unzip3 (Proxy (a, b, c) -> (Proxy a, Proxy b, Proxy c))
-> Proxy (a, b, c) -> (Proxy a, Proxy b, Proxy c)
forall a b. (a -> b) -> a -> b
$ Value (Ptr (Tuple (a, b, c))) -> Proxy (a, b, c)
forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 Value (Ptr (Tuple (a, b, c)))
ptr of
         (Proxy a
pa,Proxy b
pb,Proxy c
pc) ->
            Value (Ptr (Tuple (a, b, c)))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> CodeGenFunction r ()
forall a r c.
Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
-> CodeGenFunction r c
runElements Value (Ptr (Tuple (a, b, c)))
ptr (ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
 -> CodeGenFunction r ())
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$
               Proxy a
-> ValueOf a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a r.
C a =>
Proxy a
-> ValueOf a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
storeElement Proxy a
pa ValueOf a
a ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a b.
ReaderT BytePtr (StateT Int (CodeGenFunction r)) a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Proxy b
-> ValueOf b -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a r.
C a =>
Proxy a
-> ValueOf a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
storeElement Proxy b
pb ValueOf b
b ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a b.
ReaderT BytePtr (StateT Int (CodeGenFunction r)) a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Proxy c
-> ValueOf c -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a r.
C a =>
Proxy a
-> ValueOf a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
storeElement Proxy c
pc ValueOf c
c

runElements ::
   Value (Ptr a) ->
   MR.ReaderT BytePtr (MS.StateT Int (CodeGenFunction r)) c ->
   CodeGenFunction r c
runElements :: forall a r c.
Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
-> CodeGenFunction r c
runElements Value (Ptr a)
ptr ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
act = do
   BytePtr
bytePtr <- Value (Ptr a) -> CodeGenFunction r BytePtr
forall a r. Value (Ptr a) -> CodeGenFunction r BytePtr
castToBytePtr Value (Ptr a)
ptr
   (StateT Int (CodeGenFunction r) c -> Int -> CodeGenFunction r c)
-> Int -> StateT Int (CodeGenFunction r) c -> CodeGenFunction r c
forall a b c. (a -> b -> c) -> b -> a -> c
flip StateT Int (CodeGenFunction r) c -> Int -> CodeGenFunction r c
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
MS.evalStateT Int
0 (StateT Int (CodeGenFunction r) c -> CodeGenFunction r c)
-> StateT Int (CodeGenFunction r) c -> CodeGenFunction r c
forall a b. (a -> b) -> a -> b
$ (ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
 -> BytePtr -> StateT Int (CodeGenFunction r) c)
-> BytePtr
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
-> StateT Int (CodeGenFunction r) c
forall a b c. (a -> b -> c) -> b -> a -> c
flip ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
-> BytePtr -> StateT Int (CodeGenFunction r) c
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
MR.runReaderT BytePtr
bytePtr ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
act

loadElement ::
   (C a) =>
   LP.Proxy a ->
   MR.ReaderT BytePtr (MS.StateT Int (CodeGenFunction r)) (Tuple.ValueOf a)
loadElement :: forall a r.
C a =>
Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a)
loadElement Proxy a
proxy =
   StateT Int (CodeGenFunction r) (ValueOf a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a)
forall (m :: * -> *) a. Monad m => m a -> ReaderT BytePtr m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (StateT Int (CodeGenFunction r) (ValueOf a)
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a))
-> (Value (Ptr a) -> StateT Int (CodeGenFunction r) (ValueOf a))
-> Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CodeGenFunction r (ValueOf a)
-> StateT Int (CodeGenFunction r) (ValueOf a)
forall (m :: * -> *) a. Monad m => m a -> StateT Int m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r (ValueOf a)
 -> StateT Int (CodeGenFunction r) (ValueOf a))
-> (Value (Ptr a) -> CodeGenFunction r (ValueOf a))
-> Value (Ptr a)
-> StateT Int (CodeGenFunction r) (ValueOf a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value (Ptr a) -> CodeGenFunction r (ValueOf a)
forall r. Value (Ptr a) -> CodeGenFunction r (ValueOf a)
forall a r. C a => Value (Ptr a) -> CodeGenFunction r (ValueOf a)
load (Value (Ptr a)
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (ValueOf a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
forall a r.
C a =>
Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
elementPtr Proxy a
proxy

storeElement ::
   (C a) =>
   LP.Proxy a -> Tuple.ValueOf a ->
   MR.ReaderT BytePtr (MS.StateT Int (CodeGenFunction r)) ()
storeElement :: forall a r.
C a =>
Proxy a
-> ValueOf a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
storeElement Proxy a
proxy ValueOf a
a =
   StateT Int (CodeGenFunction r) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall (m :: * -> *) a. Monad m => m a -> ReaderT BytePtr m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (StateT Int (CodeGenFunction r) ()
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ())
-> (Value (Ptr a) -> StateT Int (CodeGenFunction r) ())
-> Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CodeGenFunction r () -> StateT Int (CodeGenFunction r) ()
forall (m :: * -> *) a. Monad m => m a -> StateT Int m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r () -> StateT Int (CodeGenFunction r) ())
-> (Value (Ptr a) -> CodeGenFunction r ())
-> Value (Ptr a)
-> StateT Int (CodeGenFunction r) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
forall r. ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
forall a r.
C a =>
ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
store ValueOf a
a (Value (Ptr a)
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ())
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
forall a r.
C a =>
Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
elementPtr Proxy a
proxy

elementPtr ::
   (C a) =>
   LP.Proxy a ->
   MR.ReaderT BytePtr
      (MS.StateT Int (CodeGenFunction r)) (LLVM.Value (Ptr a))
elementPtr :: forall a r.
C a =>
Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
elementPtr Proxy a
proxy = do
   BytePtr
ptr <- ReaderT BytePtr (StateT Int (CodeGenFunction r)) BytePtr
forall (m :: * -> *) r. Monad m => ReaderT r m r
MR.ask
   StateT Int (CodeGenFunction r) (Value (Ptr a))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
forall (m :: * -> *) a. Monad m => m a -> ReaderT BytePtr m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (StateT Int (CodeGenFunction r) (Value (Ptr a))
 -> ReaderT
      BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a)))
-> StateT Int (CodeGenFunction r) (Value (Ptr a))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
forall a b. (a -> b) -> a -> b
$ do
      Int
offset <- Proxy a -> StateT Int (CodeGenFunction r) Int
forall (m :: * -> *) a.
(Monad m, Storable a) =>
Proxy a -> StateT Int m Int
elementOffset Proxy a
proxy
      CodeGenFunction r (Value (Ptr a))
-> StateT Int (CodeGenFunction r) (Value (Ptr a))
forall (m :: * -> *) a. Monad m => m a -> StateT Int m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r (Value (Ptr a))
 -> StateT Int (CodeGenFunction r) (Value (Ptr a)))
-> CodeGenFunction r (Value (Ptr a))
-> StateT Int (CodeGenFunction r) (Value (Ptr a))
forall a b. (a -> b) -> a -> b
$ BytePtr -> CodeGenFunction r (Value (Ptr a))
forall r a. BytePtr -> CodeGenFunction r (Value (Ptr a))
castFromBytePtr (BytePtr -> CodeGenFunction r (Value (Ptr a)))
-> CodeGenFunction r BytePtr -> CodeGenFunction r (Value (Ptr a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< BytePtr
-> (Int, ())
-> CodeGenFunction r (Value (Ptr (ElementPtrType Word8 ())))
forall a o i r.
(GetElementPtr o i, IsType o, IsIndexArg a) =>
Value (Ptr o)
-> (a, i) -> CodeGenFunction r (Value (Ptr (ElementPtrType o i)))
LLVM.getElementPtr BytePtr
ptr (Int
offset, ())

elementOffset ::
   (Monad m, Store.Storable a) => LP.Proxy a -> MS.StateT Int m Int
elementOffset :: forall (m :: * -> *) a.
(Monad m, Storable a) =>
Proxy a -> StateT Int m Int
elementOffset Proxy a
proxy = do
   let dummy :: a
dummy = Proxy a -> a
forall a. Proxy a -> a
elementFromProxy Proxy a
proxy
   (Int -> Int) -> StateT Int m ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
MS.modify (Int -> Int -> Int
roundUp (Int -> Int -> Int) -> Int -> Int -> Int
forall a b. (a -> b) -> a -> b
$ a -> Int
forall a. Storable a => a -> Int
Store.alignment a
dummy)
   Int
offset <- StateT Int m Int
forall (m :: * -> *) s. Monad m => StateT s m s
MS.get
   (Int -> Int) -> StateT Int m ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
MS.modify (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ a -> Int
forall a. Storable a => a -> Int
Store.sizeOf a
dummy)
   Int -> StateT Int m Int
forall a. a -> StateT Int m a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
offset


instance
   (TypeNum.Positive n, Vector a, Tuple.VectorValue n a,
    Tuple.Phi (Tuple.VectorValueOf n a)) =>
      C (LLVM.Vector n a) where
   load :: forall r.
Value (Ptr (Vector n a))
-> CodeGenFunction r (ValueOf (Vector n a))
load Value (Ptr (Vector n a))
ptr =
      Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
forall a n r.
(Vector a, Positive n) =>
Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
forall n r.
Positive n =>
Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
assembleVector (Value (Ptr (Vector n a)) -> Proxy a
forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 Value (Ptr (Vector n a))
ptr) (Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a))
-> CodeGenFunction r (Vector n (ValueOf a))
-> CodeGenFunction r (VectorValueOf n a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr (Vector n a))
-> CodeGenFunction r (Vector n (ValueOf a))
forall (f :: * -> *) a al r.
(Applicative f, Traversable f, C a, ValueOf a ~ al) =>
Value (Ptr (f a)) -> CodeGenFunction r (f al)
loadApplicative Value (Ptr (Vector n a))
ptr
   store :: forall r.
ValueOf (Vector n a)
-> Value (Ptr (Vector n a)) -> CodeGenFunction r ()
store ValueOf (Vector n a)
a Value (Ptr (Vector n a))
ptr =
      (Vector n (ValueOf a)
 -> Value (Ptr (Vector n a)) -> CodeGenFunction r ())
-> Value (Ptr (Vector n a))
-> Vector n (ValueOf a)
-> CodeGenFunction r ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip Vector n (ValueOf a)
-> Value (Ptr (Vector n a)) -> CodeGenFunction r ()
forall (f :: * -> *) a al r.
(Foldable f, C a, ValueOf a ~ al) =>
f al -> Value (Ptr (f a)) -> CodeGenFunction r ()
storeFoldable Value (Ptr (Vector n a))
ptr
         (Vector n (ValueOf a) -> CodeGenFunction r ())
-> CodeGenFunction r (Vector n (ValueOf a)) -> CodeGenFunction r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
forall a n r.
(Vector a, Positive n) =>
Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
forall n r.
Positive n =>
Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
disassembleVector (Value (Ptr (Vector n a)) -> Proxy a
forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 Value (Ptr (Vector n a))
ptr) VectorValueOf n a
ValueOf (Vector n a)
a

class (C a) => Vector a where
   assembleVector ::
      (TypeNum.Positive n) =>
      LP.Proxy a -> LLVM.Vector n (Tuple.ValueOf a) ->
      CodeGenFunction r (Tuple.VectorValueOf n a)
   disassembleVector ::
      (TypeNum.Positive n) =>
      LP.Proxy a -> Tuple.VectorValueOf n a ->
      CodeGenFunction r (LLVM.Vector n (Tuple.ValueOf a))

assemblePrimitive ::
   (TypeNum.Positive n, LLVM.IsPrimitive a) =>
   LLVM.Vector n (Value a) -> CodeGenFunction r (Value (LLVM.Vector n a))
assemblePrimitive :: forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive =
   (Value (Vector n a)
 -> (Word32, Value a) -> CodeGenFunction r (Value (Vector n a)))
-> Value (Vector n a)
-> [(Word32, Value a)]
-> CodeGenFunction r (Value (Vector n a))
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM
      (\Value (Vector n a)
v (Word32
i,Value a
x) -> Value (Vector n a)
-> Value a
-> Value Word32
-> CodeGenFunction r (Value (Vector n a))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a)
-> Value a
-> Value Word32
-> CodeGenFunction r (Value (Vector n a))
LLVM.insertelement Value (Vector n a)
v Value a
x (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
LLVM.valueOf Word32
i))
      (ConstValue (Vector n a) -> Value (Vector n a)
forall a. ConstValue a -> Value a
LLVM.value ConstValue (Vector n a)
forall a. IsType a => ConstValue a
LLVM.undef)
    ([(Word32, Value a)] -> CodeGenFunction r (Value (Vector n a)))
-> (Vector n (Value a) -> [(Word32, Value a)])
-> Vector n (Value a)
-> CodeGenFunction r (Value (Vector n a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word32] -> [Value a] -> [(Word32, Value a)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Word32
0..] ([Value a] -> [(Word32, Value a)])
-> (Vector n (Value a) -> [Value a])
-> Vector n (Value a)
-> [(Word32, Value a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector n (Value a) -> [Value a]
forall a. Vector n a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Fold.toList

disassemblePrimitive ::
   (TypeNum.Positive n, LLVM.IsPrimitive a) =>
   Value (LLVM.Vector n a) -> CodeGenFunction r (LLVM.Vector n (Value a))
disassemblePrimitive :: forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive Value (Vector n a)
v =
   (Word32 -> CodeGenFunction r (Value a))
-> Vector n Word32 -> CodeGenFunction r (Vector n (Value a))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector n a -> m (Vector n b)
Trav.mapM (Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
LLVM.extractelement Value (Vector n a)
v (Value Word32 -> CodeGenFunction r (Value a))
-> (Word32 -> Value Word32)
-> Word32
-> CodeGenFunction r (Value a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Value Word32
forall a. IsConst a => a -> Value a
LLVM.valueOf) Vector n Word32
forall (f :: * -> *). (Applicative f, Traversable f) => f Word32
indices

indices :: (Applicative f, Trav.Traversable f) => f Word32
indices :: forall (f :: * -> *). (Applicative f, Traversable f) => f Word32
indices =
   (State Word32 (f Word32) -> Word32 -> f Word32)
-> Word32 -> State Word32 (f Word32) -> f Word32
forall a b c. (a -> b -> c) -> b -> a -> c
flip State Word32 (f Word32) -> Word32 -> f Word32
forall s a. State s a -> s -> a
MS.evalState Word32
0 (State Word32 (f Word32) -> f Word32)
-> State Word32 (f Word32) -> f Word32
forall a b. (a -> b) -> a -> b
$ f (StateT Word32 Identity Word32) -> State Word32 (f Word32)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => f (f a) -> f (f a)
Trav.sequenceA (f (StateT Word32 Identity Word32) -> State Word32 (f Word32))
-> f (StateT Word32 Identity Word32) -> State Word32 (f Word32)
forall a b. (a -> b) -> a -> b
$ StateT Word32 Identity Word32 -> f (StateT Word32 Identity Word32)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (StateT Word32 Identity Word32
 -> f (StateT Word32 Identity Word32))
-> StateT Word32 Identity Word32
-> f (StateT Word32 Identity Word32)
forall a b. (a -> b) -> a -> b
$ (Word32 -> (Word32, Word32)) -> StateT Word32 Identity Word32
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
MS.state (\Word32
k -> (Word32
k,Word32
kWord32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
+Word32
1))

instance Vector Float where
   assembleVector :: forall n r.
Positive n =>
Proxy Float
-> Vector n (ValueOf Float)
-> CodeGenFunction r (VectorValueOf n Float)
assembleVector Proxy Float
LP.Proxy = Vector n (Value Float)
-> CodeGenFunction r (Value (Vector n Float))
Vector n (ValueOf Float)
-> CodeGenFunction r (VectorValueOf n Float)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Float
-> VectorValueOf n Float
-> CodeGenFunction r (Vector n (ValueOf Float))
disassembleVector Proxy Float
LP.Proxy = Value (Vector n Float)
-> CodeGenFunction r (Vector n (Value Float))
VectorValueOf n Float
-> CodeGenFunction r (Vector n (ValueOf Float))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Double where
   assembleVector :: forall n r.
Positive n =>
Proxy Double
-> Vector n (ValueOf Double)
-> CodeGenFunction r (VectorValueOf n Double)
assembleVector Proxy Double
LP.Proxy = Vector n (Value Double)
-> CodeGenFunction r (Value (Vector n Double))
Vector n (ValueOf Double)
-> CodeGenFunction r (VectorValueOf n Double)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Double
-> VectorValueOf n Double
-> CodeGenFunction r (Vector n (ValueOf Double))
disassembleVector Proxy Double
LP.Proxy = Value (Vector n Double)
-> CodeGenFunction r (Vector n (Value Double))
VectorValueOf n Double
-> CodeGenFunction r (Vector n (ValueOf Double))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Word where
   assembleVector :: forall n r.
Positive n =>
Proxy Word
-> Vector n (ValueOf Word)
-> CodeGenFunction r (VectorValueOf n Word)
assembleVector Proxy Word
LP.Proxy = Vector n (Value Word) -> CodeGenFunction r (Value (Vector n Word))
Vector n (ValueOf Word) -> CodeGenFunction r (VectorValueOf n Word)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Word
-> VectorValueOf n Word
-> CodeGenFunction r (Vector n (ValueOf Word))
disassembleVector Proxy Word
LP.Proxy = Value (Vector n Word) -> CodeGenFunction r (Vector n (Value Word))
VectorValueOf n Word -> CodeGenFunction r (Vector n (ValueOf Word))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Word8 where
   assembleVector :: forall n r.
Positive n =>
Proxy Word8
-> Vector n (ValueOf Word8)
-> CodeGenFunction r (VectorValueOf n Word8)
assembleVector Proxy Word8
LP.Proxy = Vector n (Value Word8)
-> CodeGenFunction r (Value (Vector n Word8))
Vector n (ValueOf Word8)
-> CodeGenFunction r (VectorValueOf n Word8)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Word8
-> VectorValueOf n Word8
-> CodeGenFunction r (Vector n (ValueOf Word8))
disassembleVector Proxy Word8
LP.Proxy = Value (Vector n Word8)
-> CodeGenFunction r (Vector n (Value Word8))
VectorValueOf n Word8
-> CodeGenFunction r (Vector n (ValueOf Word8))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Word16 where
   assembleVector :: forall n r.
Positive n =>
Proxy Word16
-> Vector n (ValueOf Word16)
-> CodeGenFunction r (VectorValueOf n Word16)
assembleVector Proxy Word16
LP.Proxy = Vector n (Value Word16)
-> CodeGenFunction r (Value (Vector n Word16))
Vector n (ValueOf Word16)
-> CodeGenFunction r (VectorValueOf n Word16)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Word16
-> VectorValueOf n Word16
-> CodeGenFunction r (Vector n (ValueOf Word16))
disassembleVector Proxy Word16
LP.Proxy = Value (Vector n Word16)
-> CodeGenFunction r (Vector n (Value Word16))
VectorValueOf n Word16
-> CodeGenFunction r (Vector n (ValueOf Word16))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Word32 where
   assembleVector :: forall n r.
Positive n =>
Proxy Word32
-> Vector n (ValueOf Word32)
-> CodeGenFunction r (VectorValueOf n Word32)
assembleVector Proxy Word32
LP.Proxy = Vector n (Value Word32)
-> CodeGenFunction r (Value (Vector n Word32))
Vector n (ValueOf Word32)
-> CodeGenFunction r (VectorValueOf n Word32)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Word32
-> VectorValueOf n Word32
-> CodeGenFunction r (Vector n (ValueOf Word32))
disassembleVector Proxy Word32
LP.Proxy = Value (Vector n Word32)
-> CodeGenFunction r (Vector n (Value Word32))
VectorValueOf n Word32
-> CodeGenFunction r (Vector n (ValueOf Word32))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Word64 where
   assembleVector :: forall n r.
Positive n =>
Proxy Word64
-> Vector n (ValueOf Word64)
-> CodeGenFunction r (VectorValueOf n Word64)
assembleVector Proxy Word64
LP.Proxy = Vector n (Value Word64)
-> CodeGenFunction r (Value (Vector n Word64))
Vector n (ValueOf Word64)
-> CodeGenFunction r (VectorValueOf n Word64)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Word64
-> VectorValueOf n Word64
-> CodeGenFunction r (Vector n (ValueOf Word64))
disassembleVector Proxy Word64
LP.Proxy = Value (Vector n Word64)
-> CodeGenFunction r (Vector n (Value Word64))
VectorValueOf n Word64
-> CodeGenFunction r (Vector n (ValueOf Word64))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Int where
   assembleVector :: forall n r.
Positive n =>
Proxy Int
-> Vector n (ValueOf Int)
-> CodeGenFunction r (VectorValueOf n Int)
assembleVector Proxy Int
LP.Proxy = Vector n (Value Int) -> CodeGenFunction r (Value (Vector n Int))
Vector n (ValueOf Int) -> CodeGenFunction r (VectorValueOf n Int)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Int
-> VectorValueOf n Int
-> CodeGenFunction r (Vector n (ValueOf Int))
disassembleVector Proxy Int
LP.Proxy = Value (Vector n Int) -> CodeGenFunction r (Vector n (Value Int))
VectorValueOf n Int -> CodeGenFunction r (Vector n (ValueOf Int))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Int8 where
   assembleVector :: forall n r.
Positive n =>
Proxy Int8
-> Vector n (ValueOf Int8)
-> CodeGenFunction r (VectorValueOf n Int8)
assembleVector Proxy Int8
LP.Proxy = Vector n (Value Int8) -> CodeGenFunction r (Value (Vector n Int8))
Vector n (ValueOf Int8) -> CodeGenFunction r (VectorValueOf n Int8)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Int8
-> VectorValueOf n Int8
-> CodeGenFunction r (Vector n (ValueOf Int8))
disassembleVector Proxy Int8
LP.Proxy = Value (Vector n Int8) -> CodeGenFunction r (Vector n (Value Int8))
VectorValueOf n Int8 -> CodeGenFunction r (Vector n (ValueOf Int8))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Int16 where
   assembleVector :: forall n r.
Positive n =>
Proxy Int16
-> Vector n (ValueOf Int16)
-> CodeGenFunction r (VectorValueOf n Int16)
assembleVector Proxy Int16
LP.Proxy = Vector n (Value Int16)
-> CodeGenFunction r (Value (Vector n Int16))
Vector n (ValueOf Int16)
-> CodeGenFunction r (VectorValueOf n Int16)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Int16
-> VectorValueOf n Int16
-> CodeGenFunction r (Vector n (ValueOf Int16))
disassembleVector Proxy Int16
LP.Proxy = Value (Vector n Int16)
-> CodeGenFunction r (Vector n (Value Int16))
VectorValueOf n Int16
-> CodeGenFunction r (Vector n (ValueOf Int16))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Int32 where
   assembleVector :: forall n r.
Positive n =>
Proxy Int32
-> Vector n (ValueOf Int32)
-> CodeGenFunction r (VectorValueOf n Int32)
assembleVector Proxy Int32
LP.Proxy = Vector n (Value Int32)
-> CodeGenFunction r (Value (Vector n Int32))
Vector n (ValueOf Int32)
-> CodeGenFunction r (VectorValueOf n Int32)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Int32
-> VectorValueOf n Int32
-> CodeGenFunction r (Vector n (ValueOf Int32))
disassembleVector Proxy Int32
LP.Proxy = Value (Vector n Int32)
-> CodeGenFunction r (Vector n (Value Int32))
VectorValueOf n Int32
-> CodeGenFunction r (Vector n (ValueOf Int32))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Int64 where
   assembleVector :: forall n r.
Positive n =>
Proxy Int64
-> Vector n (ValueOf Int64)
-> CodeGenFunction r (VectorValueOf n Int64)
assembleVector Proxy Int64
LP.Proxy = Vector n (Value Int64)
-> CodeGenFunction r (Value (Vector n Int64))
Vector n (ValueOf Int64)
-> CodeGenFunction r (VectorValueOf n Int64)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Int64
-> VectorValueOf n Int64
-> CodeGenFunction r (Vector n (ValueOf Int64))
disassembleVector Proxy Int64
LP.Proxy = Value (Vector n Int64)
-> CodeGenFunction r (Vector n (Value Int64))
VectorValueOf n Int64
-> CodeGenFunction r (Vector n (ValueOf Int64))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Bool where
   assembleVector :: forall n r.
Positive n =>
Proxy Bool
-> Vector n (ValueOf Bool)
-> CodeGenFunction r (VectorValueOf n Bool)
assembleVector Proxy Bool
LP.Proxy = Vector n (Value Bool) -> CodeGenFunction r (Value (Vector n Bool))
Vector n (ValueOf Bool) -> CodeGenFunction r (VectorValueOf n Bool)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Bool
-> VectorValueOf n Bool
-> CodeGenFunction r (Vector n (ValueOf Bool))
disassembleVector Proxy Bool
LP.Proxy = Value (Vector n Bool) -> CodeGenFunction r (Vector n (Value Bool))
VectorValueOf n Bool -> CodeGenFunction r (Vector n (ValueOf Bool))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Bool8 where
   assembleVector :: forall n r.
Positive n =>
Proxy Bool8
-> Vector n (ValueOf Bool8)
-> CodeGenFunction r (VectorValueOf n Bool8)
assembleVector Proxy Bool8
LP.Proxy = Vector n (Value Bool) -> CodeGenFunction r (Value (Vector n Bool))
Vector n (ValueOf Bool8)
-> CodeGenFunction r (VectorValueOf n Bool8)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Bool8
-> VectorValueOf n Bool8
-> CodeGenFunction r (Vector n (ValueOf Bool8))
disassembleVector Proxy Bool8
LP.Proxy = Value (Vector n Bool) -> CodeGenFunction r (Vector n (Value Bool))
VectorValueOf n Bool8
-> CodeGenFunction r (Vector n (ValueOf Bool8))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive


instance
   (Tuple tuple, TupleVector tuple) =>
      Vector (StoreTuple.Tuple tuple) where
   assembleVector :: forall n r.
Positive n =>
Proxy (Tuple tuple)
-> Vector n (ValueOf (Tuple tuple))
-> CodeGenFunction r (VectorValueOf n (Tuple tuple))
assembleVector = Proxy tuple
-> Vector n (ValueOf tuple)
-> CodeGenFunction r (VectorValueOf n tuple)
forall a n r.
(TupleVector a, Positive n) =>
Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
forall n r.
Positive n =>
Proxy tuple
-> Vector n (ValueOf tuple)
-> CodeGenFunction r (VectorValueOf n tuple)
deinterleave (Proxy tuple
 -> Vector n (ValueOf tuple)
 -> CodeGenFunction r (VectorValueOf n tuple))
-> (Proxy (Tuple tuple) -> Proxy tuple)
-> Proxy (Tuple tuple)
-> Vector n (ValueOf tuple)
-> CodeGenFunction r (VectorValueOf n tuple)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Tuple tuple -> tuple) -> Proxy (Tuple tuple) -> Proxy tuple
forall a b. (a -> b) -> Proxy a -> Proxy b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Tuple tuple -> tuple
forall a. Tuple a -> a
StoreTuple.getTuple
   disassembleVector :: forall n r.
Positive n =>
Proxy (Tuple tuple)
-> VectorValueOf n (Tuple tuple)
-> CodeGenFunction r (Vector n (ValueOf (Tuple tuple)))
disassembleVector = Proxy tuple
-> VectorValueOf n tuple
-> CodeGenFunction r (Vector n (ValueOf tuple))
forall a n r.
(TupleVector a, Positive n) =>
Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
forall n r.
Positive n =>
Proxy tuple
-> VectorValueOf n tuple
-> CodeGenFunction r (Vector n (ValueOf tuple))
interleave (Proxy tuple
 -> VectorValueOf n tuple
 -> CodeGenFunction r (Vector n (ValueOf tuple)))
-> (Proxy (Tuple tuple) -> Proxy tuple)
-> Proxy (Tuple tuple)
-> VectorValueOf n tuple
-> CodeGenFunction r (Vector n (ValueOf tuple))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Tuple tuple -> tuple) -> Proxy (Tuple tuple) -> Proxy tuple
forall a b. (a -> b) -> Proxy a -> Proxy b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Tuple tuple -> tuple
forall a. Tuple a -> a
StoreTuple.getTuple


class TupleVector a where
   deinterleave ::
      (TypeNum.Positive n) =>
      LP.Proxy a -> LLVM.Vector n (Tuple.ValueOf a) ->
      CodeGenFunction r (Tuple.VectorValueOf n a)
   interleave ::
      (TypeNum.Positive n) =>
      LP.Proxy a -> Tuple.VectorValueOf n a ->
      CodeGenFunction r (LLVM.Vector n (Tuple.ValueOf a))

instance (Vector a, Vector b) => TupleVector (a,b) where
   deinterleave :: forall n r.
Positive n =>
Proxy (a, b)
-> Vector n (ValueOf (a, b))
-> CodeGenFunction r (VectorValueOf n (a, b))
deinterleave = (Proxy a
 -> Proxy b
 -> Vector n (ValueOf (a, b))
 -> CodeGenFunction r (VectorValueOf n (a, b)))
-> Proxy (a, b)
-> Vector n (ValueOf (a, b))
-> CodeGenFunction r (VectorValueOf n (a, b))
forall (f :: * -> *) a b g.
Functor f =>
(f a -> f b -> g) -> f (a, b) -> g
FuncHT.uncurry ((Proxy a
  -> Proxy b
  -> Vector n (ValueOf (a, b))
  -> CodeGenFunction r (VectorValueOf n (a, b)))
 -> Proxy (a, b)
 -> Vector n (ValueOf (a, b))
 -> CodeGenFunction r (VectorValueOf n (a, b)))
-> (Proxy a
    -> Proxy b
    -> Vector n (ValueOf (a, b))
    -> CodeGenFunction r (VectorValueOf n (a, b)))
-> Proxy (a, b)
-> Vector n (ValueOf (a, b))
-> CodeGenFunction r (VectorValueOf n (a, b))
forall a b. (a -> b) -> a -> b
$ \Proxy a
pa Proxy b
pb -> (Vector n (ValueOf a)
 -> Vector n (ValueOf b)
 -> CodeGenFunction r (VectorValueOf n (a, b)))
-> Vector n (ValueOf a, ValueOf b)
-> CodeGenFunction r (VectorValueOf n (a, b))
forall (f :: * -> *) a b g.
Functor f =>
(f a -> f b -> g) -> f (a, b) -> g
FuncHT.uncurry ((Vector n (ValueOf a)
  -> Vector n (ValueOf b)
  -> CodeGenFunction r (VectorValueOf n (a, b)))
 -> Vector n (ValueOf a, ValueOf b)
 -> CodeGenFunction r (VectorValueOf n (a, b)))
-> (Vector n (ValueOf a)
    -> Vector n (ValueOf b)
    -> CodeGenFunction r (VectorValueOf n (a, b)))
-> Vector n (ValueOf a, ValueOf b)
-> CodeGenFunction r (VectorValueOf n (a, b))
forall a b. (a -> b) -> a -> b
$ \Vector n (ValueOf a)
a Vector n (ValueOf b)
b ->
      (VectorValueOf n a
 -> VectorValueOf n b -> (VectorValueOf n a, VectorValueOf n b))
-> CodeGenFunction r (VectorValueOf n a)
-> CodeGenFunction r (VectorValueOf n b)
-> CodeGenFunction r (VectorValueOf n a, VectorValueOf n b)
forall (m :: * -> *) a b r.
Applicative m =>
(a -> b -> r) -> m a -> m b -> m r
App.lift2 (,) (Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
forall a n r.
(Vector a, Positive n) =>
Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
forall n r.
Positive n =>
Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
assembleVector Proxy a
pa Vector n (ValueOf a)
a) (Proxy b
-> Vector n (ValueOf b) -> CodeGenFunction r (VectorValueOf n b)
forall a n r.
(Vector a, Positive n) =>
Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
forall n r.
Positive n =>
Proxy b
-> Vector n (ValueOf b) -> CodeGenFunction r (VectorValueOf n b)
assembleVector Proxy b
pb Vector n (ValueOf b)
b)
   interleave :: forall n r.
Positive n =>
Proxy (a, b)
-> VectorValueOf n (a, b)
-> CodeGenFunction r (Vector n (ValueOf (a, b)))
interleave = (Proxy a
 -> Proxy b
 -> VectorValueOf n (a, b)
 -> CodeGenFunction r (Vector n (ValueOf (a, b))))
-> Proxy (a, b)
-> VectorValueOf n (a, b)
-> CodeGenFunction r (Vector n (ValueOf (a, b)))
forall (f :: * -> *) a b g.
Functor f =>
(f a -> f b -> g) -> f (a, b) -> g
FuncHT.uncurry ((Proxy a
  -> Proxy b
  -> VectorValueOf n (a, b)
  -> CodeGenFunction r (Vector n (ValueOf (a, b))))
 -> Proxy (a, b)
 -> VectorValueOf n (a, b)
 -> CodeGenFunction r (Vector n (ValueOf (a, b))))
-> (Proxy a
    -> Proxy b
    -> VectorValueOf n (a, b)
    -> CodeGenFunction r (Vector n (ValueOf (a, b))))
-> Proxy (a, b)
-> VectorValueOf n (a, b)
-> CodeGenFunction r (Vector n (ValueOf (a, b)))
forall a b. (a -> b) -> a -> b
$ \Proxy a
pa Proxy b
pb (VectorValueOf n a
a,VectorValueOf n b
b) ->
      (Vector n (ValueOf a)
 -> Vector n (ValueOf b) -> Vector n (ValueOf a, ValueOf b))
-> CodeGenFunction r (Vector n (ValueOf a))
-> CodeGenFunction r (Vector n (ValueOf b))
-> CodeGenFunction r (Vector n (ValueOf a, ValueOf b))
forall (m :: * -> *) a b r.
Applicative m =>
(a -> b -> r) -> m a -> m b -> m r
App.lift2 ((ValueOf a -> ValueOf b -> (ValueOf a, ValueOf b))
-> Vector n (ValueOf a)
-> Vector n (ValueOf b)
-> Vector n (ValueOf a, ValueOf b)
forall (m :: * -> *) a b r.
Applicative m =>
(a -> b -> r) -> m a -> m b -> m r
App.lift2 (,))
         (Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
forall a n r.
(Vector a, Positive n) =>
Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
forall n r.
Positive n =>
Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
disassembleVector Proxy a
pa VectorValueOf n a
a) (Proxy b
-> VectorValueOf n b -> CodeGenFunction r (Vector n (ValueOf b))
forall a n r.
(Vector a, Positive n) =>
Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
forall n r.
Positive n =>
Proxy b
-> VectorValueOf n b -> CodeGenFunction r (Vector n (ValueOf b))
disassembleVector Proxy b
pb VectorValueOf n b
b)

instance (Vector a, Vector b, Vector c) => TupleVector (a,b,c) where
   deinterleave :: forall n r.
Positive n =>
Proxy (a, b, c)
-> Vector n (ValueOf (a, b, c))
-> CodeGenFunction r (VectorValueOf n (a, b, c))
deinterleave = (Proxy a
 -> Proxy b
 -> Proxy c
 -> Vector n (ValueOf (a, b, c))
 -> CodeGenFunction r (VectorValueOf n (a, b, c)))
-> Proxy (a, b, c)
-> Vector n (ValueOf (a, b, c))
-> CodeGenFunction r (VectorValueOf n (a, b, c))
forall (f :: * -> *) a b c g.
Functor f =>
(f a -> f b -> f c -> g) -> f (a, b, c) -> g
FuncHT.uncurry3 ((Proxy a
  -> Proxy b
  -> Proxy c
  -> Vector n (ValueOf (a, b, c))
  -> CodeGenFunction r (VectorValueOf n (a, b, c)))
 -> Proxy (a, b, c)
 -> Vector n (ValueOf (a, b, c))
 -> CodeGenFunction r (VectorValueOf n (a, b, c)))
-> (Proxy a
    -> Proxy b
    -> Proxy c
    -> Vector n (ValueOf (a, b, c))
    -> CodeGenFunction r (VectorValueOf n (a, b, c)))
-> Proxy (a, b, c)
-> Vector n (ValueOf (a, b, c))
-> CodeGenFunction r (VectorValueOf n (a, b, c))
forall a b. (a -> b) -> a -> b
$ \Proxy a
pa Proxy b
pb Proxy c
pc -> (Vector n (ValueOf a)
 -> Vector n (ValueOf b)
 -> Vector n (ValueOf c)
 -> CodeGenFunction r (VectorValueOf n (a, b, c)))
-> Vector n (ValueOf a, ValueOf b, ValueOf c)
-> CodeGenFunction r (VectorValueOf n (a, b, c))
forall (f :: * -> *) a b c g.
Functor f =>
(f a -> f b -> f c -> g) -> f (a, b, c) -> g
FuncHT.uncurry3 ((Vector n (ValueOf a)
  -> Vector n (ValueOf b)
  -> Vector n (ValueOf c)
  -> CodeGenFunction r (VectorValueOf n (a, b, c)))
 -> Vector n (ValueOf a, ValueOf b, ValueOf c)
 -> CodeGenFunction r (VectorValueOf n (a, b, c)))
-> (Vector n (ValueOf a)
    -> Vector n (ValueOf b)
    -> Vector n (ValueOf c)
    -> CodeGenFunction r (VectorValueOf n (a, b, c)))
-> Vector n (ValueOf a, ValueOf b, ValueOf c)
-> CodeGenFunction r (VectorValueOf n (a, b, c))
forall a b. (a -> b) -> a -> b
$ \Vector n (ValueOf a)
a Vector n (ValueOf b)
b Vector n (ValueOf c)
c ->
      (VectorValueOf n a
 -> VectorValueOf n b
 -> VectorValueOf n c
 -> (VectorValueOf n a, VectorValueOf n b, VectorValueOf n c))
-> CodeGenFunction r (VectorValueOf n a)
-> CodeGenFunction r (VectorValueOf n b)
-> CodeGenFunction r (VectorValueOf n c)
-> CodeGenFunction
     r (VectorValueOf n a, VectorValueOf n b, VectorValueOf n c)
forall (m :: * -> *) a b c r.
Applicative m =>
(a -> b -> c -> r) -> m a -> m b -> m c -> m r
App.lift3 (,,)
         (Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
forall a n r.
(Vector a, Positive n) =>
Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
forall n r.
Positive n =>
Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
assembleVector Proxy a
pa Vector n (ValueOf a)
a)
         (Proxy b
-> Vector n (ValueOf b) -> CodeGenFunction r (VectorValueOf n b)
forall a n r.
(Vector a, Positive n) =>
Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
forall n r.
Positive n =>
Proxy b
-> Vector n (ValueOf b) -> CodeGenFunction r (VectorValueOf n b)
assembleVector Proxy b
pb Vector n (ValueOf b)
b)
         (Proxy c
-> Vector n (ValueOf c) -> CodeGenFunction r (VectorValueOf n c)
forall a n r.
(Vector a, Positive n) =>
Proxy a
-> Vector n (ValueOf a) -> CodeGenFunction r (VectorValueOf n a)
forall n r.
Positive n =>
Proxy c
-> Vector n (ValueOf c) -> CodeGenFunction r (VectorValueOf n c)
assembleVector Proxy c
pc Vector n (ValueOf c)
c)
   interleave :: forall n r.
Positive n =>
Proxy (a, b, c)
-> VectorValueOf n (a, b, c)
-> CodeGenFunction r (Vector n (ValueOf (a, b, c)))
interleave = (Proxy a
 -> Proxy b
 -> Proxy c
 -> VectorValueOf n (a, b, c)
 -> CodeGenFunction r (Vector n (ValueOf (a, b, c))))
-> Proxy (a, b, c)
-> VectorValueOf n (a, b, c)
-> CodeGenFunction r (Vector n (ValueOf (a, b, c)))
forall (f :: * -> *) a b c g.
Functor f =>
(f a -> f b -> f c -> g) -> f (a, b, c) -> g
FuncHT.uncurry3 ((Proxy a
  -> Proxy b
  -> Proxy c
  -> VectorValueOf n (a, b, c)
  -> CodeGenFunction r (Vector n (ValueOf (a, b, c))))
 -> Proxy (a, b, c)
 -> VectorValueOf n (a, b, c)
 -> CodeGenFunction r (Vector n (ValueOf (a, b, c))))
-> (Proxy a
    -> Proxy b
    -> Proxy c
    -> VectorValueOf n (a, b, c)
    -> CodeGenFunction r (Vector n (ValueOf (a, b, c))))
-> Proxy (a, b, c)
-> VectorValueOf n (a, b, c)
-> CodeGenFunction r (Vector n (ValueOf (a, b, c)))
forall a b. (a -> b) -> a -> b
$ \Proxy a
pa Proxy b
pb Proxy c
pc (VectorValueOf n a
a,VectorValueOf n b
b,VectorValueOf n c
c) ->
      (Vector n (ValueOf a)
 -> Vector n (ValueOf b)
 -> Vector n (ValueOf c)
 -> Vector n (ValueOf a, ValueOf b, ValueOf c))
-> CodeGenFunction r (Vector n (ValueOf a))
-> CodeGenFunction r (Vector n (ValueOf b))
-> CodeGenFunction r (Vector n (ValueOf c))
-> CodeGenFunction r (Vector n (ValueOf a, ValueOf b, ValueOf c))
forall (m :: * -> *) a b c r.
Applicative m =>
(a -> b -> c -> r) -> m a -> m b -> m c -> m r
App.lift3 ((ValueOf a
 -> ValueOf b -> ValueOf c -> (ValueOf a, ValueOf b, ValueOf c))
-> Vector n (ValueOf a)
-> Vector n (ValueOf b)
-> Vector n (ValueOf c)
-> Vector n (ValueOf a, ValueOf b, ValueOf c)
forall (m :: * -> *) a b c r.
Applicative m =>
(a -> b -> c -> r) -> m a -> m b -> m c -> m r
App.lift3 (,,))
         (Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
forall a n r.
(Vector a, Positive n) =>
Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
forall n r.
Positive n =>
Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
disassembleVector Proxy a
pa VectorValueOf n a
a)
         (Proxy b
-> VectorValueOf n b -> CodeGenFunction r (Vector n (ValueOf b))
forall a n r.
(Vector a, Positive n) =>
Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
forall n r.
Positive n =>
Proxy b
-> VectorValueOf n b -> CodeGenFunction r (Vector n (ValueOf b))
disassembleVector Proxy b
pb VectorValueOf n b
b)
         (Proxy c
-> VectorValueOf n c -> CodeGenFunction r (Vector n (ValueOf c))
forall a n r.
(Vector a, Positive n) =>
Proxy a
-> VectorValueOf n a -> CodeGenFunction r (Vector n (ValueOf a))
forall n r.
Positive n =>
Proxy c
-> VectorValueOf n c -> CodeGenFunction r (Vector n (ValueOf c))
disassembleVector Proxy c
pc VectorValueOf n c
c)


{-
instance Storable () available since base-4.9/GHC-8.0.
Before we need Data.Orphans.
-}
instance C () where
   load :: forall r. Value (Ptr ()) -> CodeGenFunction r (ValueOf ())
load Value (Ptr ())
_ptr = () -> CodeGenFunction r ()
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
   store :: forall r. ValueOf () -> Value (Ptr ()) -> CodeGenFunction r ()
store () Value (Ptr ())
_ptr = () -> CodeGenFunction r ()
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()


loadNewtype ::
   (C a, Tuple.ValueOf a ~ al) =>
   (a -> wrapped) ->
   (al -> wrappedl) ->
   Value (Ptr wrapped) -> CodeGenFunction r wrappedl
loadNewtype :: forall a al wrapped wrappedl r.
(C a, ValueOf a ~ al) =>
(a -> wrapped)
-> (al -> wrappedl)
-> Value (Ptr wrapped)
-> CodeGenFunction r wrappedl
loadNewtype a -> wrapped
wrap al -> wrappedl
wrapl =
   (al -> wrappedl)
-> CodeGenFunction r al -> CodeGenFunction r wrappedl
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap al -> wrappedl
wrapl (CodeGenFunction r al -> CodeGenFunction r wrappedl)
-> (Value (Ptr a) -> CodeGenFunction r al)
-> Value (Ptr a)
-> CodeGenFunction r wrappedl
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value (Ptr a) -> CodeGenFunction r al
Value (Ptr a) -> CodeGenFunction r (ValueOf a)
forall r. Value (Ptr a) -> CodeGenFunction r (ValueOf a)
forall a r. C a => Value (Ptr a) -> CodeGenFunction r (ValueOf a)
load (Value (Ptr a) -> CodeGenFunction r wrappedl)
-> (Value (Ptr wrapped) -> CodeGenFunction r (Value (Ptr a)))
-> Value (Ptr wrapped)
-> CodeGenFunction r wrappedl
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< (a -> wrapped)
-> Value (Ptr wrapped) -> CodeGenFunction r (Value (Ptr a))
forall a b r.
(a -> b) -> Value (Ptr b) -> CodeGenFunction r (Value (Ptr a))
rmapPtr a -> wrapped
wrap

storeNewtype ::
   (C a, Tuple.ValueOf a ~ al) =>
   (a -> wrapped) ->
   (wrappedl -> al) ->
   wrappedl -> Value (Ptr wrapped) -> CodeGenFunction r ()
storeNewtype :: forall a al wrapped wrappedl r.
(C a, ValueOf a ~ al) =>
(a -> wrapped)
-> (wrappedl -> al)
-> wrappedl
-> Value (Ptr wrapped)
-> CodeGenFunction r ()
storeNewtype a -> wrapped
wrap wrappedl -> al
unwrapl wrappedl
y =
   ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
forall r. ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
forall a r.
C a =>
ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
store (wrappedl -> al
unwrapl wrappedl
y) (Value (Ptr a) -> CodeGenFunction r ())
-> (Value (Ptr wrapped) -> CodeGenFunction r (Value (Ptr a)))
-> Value (Ptr wrapped)
-> CodeGenFunction r ()
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< (a -> wrapped)
-> Value (Ptr wrapped) -> CodeGenFunction r (Value (Ptr a))
forall a b r.
(a -> b) -> Value (Ptr b) -> CodeGenFunction r (Value (Ptr a))
rmapPtr a -> wrapped
wrap

rmapPtr :: (a -> b) -> Value (Ptr b) -> CodeGenFunction r (Value (Ptr a))
rmapPtr :: forall a b r.
(a -> b) -> Value (Ptr b) -> CodeGenFunction r (Value (Ptr a))
rmapPtr a -> b
_f = Value (Ptr b) -> CodeGenFunction r (Value (Ptr a))
forall (value :: * -> *) a b r.
(ValueCons value, IsSized a, IsSized b, SizeOf a ~ SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.bitcast


loadTraversable ::
   (NonEmptyC.Repeat f, Trav.Traversable f, C a, Tuple.ValueOf a ~ al) =>
   Value (Ptr (f a)) -> CodeGenFunction r (f al)
loadTraversable :: forall (f :: * -> *) a al r.
(Repeat f, Traversable f, C a, ValueOf a ~ al) =>
Value (Ptr (f a)) -> CodeGenFunction r (f al)
loadTraversable =
   (StateT (Value (Ptr a)) (CodeGenFunction r) (f al)
-> Value (Ptr a) -> CodeGenFunction r (f al)
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
MS.evalStateT (StateT (Value (Ptr a)) (CodeGenFunction r) (f al)
 -> Value (Ptr a) -> CodeGenFunction r (f al))
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f al)
-> Value (Ptr a)
-> CodeGenFunction r (f al)
forall a b. (a -> b) -> a -> b
$ f (StateT (Value (Ptr a)) (CodeGenFunction r) al)
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f al)
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => f (m a) -> m (f a)
Trav.sequence (f (StateT (Value (Ptr a)) (CodeGenFunction r) al)
 -> StateT (Value (Ptr a)) (CodeGenFunction r) (f al))
-> f (StateT (Value (Ptr a)) (CodeGenFunction r) al)
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f al)
forall a b. (a -> b) -> a -> b
$ StateT (Value (Ptr a)) (CodeGenFunction r) al
-> f (StateT (Value (Ptr a)) (CodeGenFunction r) al)
forall a. a -> f a
forall (f :: * -> *) a. Repeat f => a -> f a
NonEmptyC.repeat (StateT (Value (Ptr a)) (CodeGenFunction r) al
 -> f (StateT (Value (Ptr a)) (CodeGenFunction r) al))
-> StateT (Value (Ptr a)) (CodeGenFunction r) al
-> f (StateT (Value (Ptr a)) (CodeGenFunction r) al)
forall a b. (a -> b) -> a -> b
$ StateT (Value (Ptr a)) (CodeGenFunction r) al
forall a al r.
(C a, ValueOf a ~ al) =>
StateT (Value (Ptr a)) (CodeGenFunction r) al
loadState)
      (Value (Ptr a) -> CodeGenFunction r (f al))
-> (Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a)))
-> Value (Ptr (f a))
-> CodeGenFunction r (f al)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
forall (f :: * -> *) a r.
Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
castElementPtr

loadApplicative ::
   (Applicative f, Trav.Traversable f, C a, Tuple.ValueOf a ~ al) =>
   Value (Ptr (f a)) -> CodeGenFunction r (f al)
loadApplicative :: forall (f :: * -> *) a al r.
(Applicative f, Traversable f, C a, ValueOf a ~ al) =>
Value (Ptr (f a)) -> CodeGenFunction r (f al)
loadApplicative =
   (StateT (Value (Ptr a)) (CodeGenFunction r) (f al)
-> Value (Ptr a) -> CodeGenFunction r (f al)
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
MS.evalStateT (StateT (Value (Ptr a)) (CodeGenFunction r) (f al)
 -> Value (Ptr a) -> CodeGenFunction r (f al))
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f al)
-> Value (Ptr a)
-> CodeGenFunction r (f al)
forall a b. (a -> b) -> a -> b
$ f (StateT (Value (Ptr a)) (CodeGenFunction r) al)
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f al)
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => f (m a) -> m (f a)
Trav.sequence (f (StateT (Value (Ptr a)) (CodeGenFunction r) al)
 -> StateT (Value (Ptr a)) (CodeGenFunction r) (f al))
-> f (StateT (Value (Ptr a)) (CodeGenFunction r) al)
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f al)
forall a b. (a -> b) -> a -> b
$ StateT (Value (Ptr a)) (CodeGenFunction r) al
-> f (StateT (Value (Ptr a)) (CodeGenFunction r) al)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure StateT (Value (Ptr a)) (CodeGenFunction r) al
forall a al r.
(C a, ValueOf a ~ al) =>
StateT (Value (Ptr a)) (CodeGenFunction r) al
loadState) (Value (Ptr a) -> CodeGenFunction r (f al))
-> (Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a)))
-> Value (Ptr (f a))
-> CodeGenFunction r (f al)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
forall (f :: * -> *) a r.
Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
castElementPtr

loadState ::
   (C a, Tuple.ValueOf a ~ al) =>
   MS.StateT (Value (Ptr a)) (CodeGenFunction r) al
loadState :: forall a al r.
(C a, ValueOf a ~ al) =>
StateT (Value (Ptr a)) (CodeGenFunction r) al
loadState = CodeGenFunction r al
-> StateT (Value (Ptr a)) (CodeGenFunction r) al
forall (m :: * -> *) a.
Monad m =>
m a -> StateT (Value (Ptr a)) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r al
 -> StateT (Value (Ptr a)) (CodeGenFunction r) al)
-> (Value (Ptr a) -> CodeGenFunction r al)
-> Value (Ptr a)
-> StateT (Value (Ptr a)) (CodeGenFunction r) al
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value (Ptr a) -> CodeGenFunction r al
Value (Ptr a) -> CodeGenFunction r (ValueOf a)
forall r. Value (Ptr a) -> CodeGenFunction r (ValueOf a)
forall a r. C a => Value (Ptr a) -> CodeGenFunction r (ValueOf a)
load (Value (Ptr a) -> StateT (Value (Ptr a)) (CodeGenFunction r) al)
-> StateT (Value (Ptr a)) (CodeGenFunction r) (Value (Ptr a))
-> StateT (Value (Ptr a)) (CodeGenFunction r) al
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< StateT (Value (Ptr a)) (CodeGenFunction r) (Value (Ptr a))
forall a ptr r.
(C a, Value (Ptr a) ~ ptr) =>
StateT ptr (CodeGenFunction r) ptr
advancePtrState


storeFoldable ::
   (Fold.Foldable f, C a, Tuple.ValueOf a ~ al) =>
   f al -> Value (Ptr (f a)) -> CodeGenFunction r ()
storeFoldable :: forall (f :: * -> *) a al r.
(Foldable f, C a, ValueOf a ~ al) =>
f al -> Value (Ptr (f a)) -> CodeGenFunction r ()
storeFoldable f al
xs = StateT (Value (Ptr a)) (CodeGenFunction r) ()
-> Value (Ptr a) -> CodeGenFunction r ()
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
MS.evalStateT ((al -> StateT (Value (Ptr a)) (CodeGenFunction r) ())
-> f al -> StateT (Value (Ptr a)) (CodeGenFunction r) ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
Fold.mapM_ al -> StateT (Value (Ptr a)) (CodeGenFunction r) ()
forall a al r.
(C a, ValueOf a ~ al) =>
al -> StateT (Value (Ptr a)) (CodeGenFunction r) ()
storeState f al
xs) (Value (Ptr a) -> CodeGenFunction r ())
-> (Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a)))
-> Value (Ptr (f a))
-> CodeGenFunction r ()
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
forall (f :: * -> *) a r.
Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
castElementPtr

storeState ::
   (C a, Tuple.ValueOf a ~ al) =>
   al -> MS.StateT (Value (Ptr a)) (CodeGenFunction r) ()
storeState :: forall a al r.
(C a, ValueOf a ~ al) =>
al -> StateT (Value (Ptr a)) (CodeGenFunction r) ()
storeState al
a = CodeGenFunction r ()
-> StateT (Value (Ptr a)) (CodeGenFunction r) ()
forall (m :: * -> *) a.
Monad m =>
m a -> StateT (Value (Ptr a)) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r ()
 -> StateT (Value (Ptr a)) (CodeGenFunction r) ())
-> (Value (Ptr a) -> CodeGenFunction r ())
-> Value (Ptr a)
-> StateT (Value (Ptr a)) (CodeGenFunction r) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
forall r. ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
forall a r.
C a =>
ValueOf a -> Value (Ptr a) -> CodeGenFunction r ()
store al
ValueOf a
a (Value (Ptr a) -> StateT (Value (Ptr a)) (CodeGenFunction r) ())
-> StateT (Value (Ptr a)) (CodeGenFunction r) (Value (Ptr a))
-> StateT (Value (Ptr a)) (CodeGenFunction r) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< StateT (Value (Ptr a)) (CodeGenFunction r) (Value (Ptr a))
forall a ptr r.
(C a, Value (Ptr a) ~ ptr) =>
StateT ptr (CodeGenFunction r) ptr
advancePtrState


update :: (Monad m) => (a -> m a) -> MS.StateT a m a
update :: forall (m :: * -> *) a. Monad m => (a -> m a) -> StateT a m a
update a -> m a
f = (a -> m (a, a)) -> StateT a m a
forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
MS.StateT ((a -> m (a, a)) -> StateT a m a)
-> (a -> m (a, a)) -> StateT a m a
forall a b. (a -> b) -> a -> b
$ \a
a0 -> do a
a1 <- a -> m a
f a
a0; (a, a) -> m (a, a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a0,a
a1)

advancePtrState ::
   (C a, Value (Ptr a) ~ ptr) =>
   MS.StateT ptr (CodeGenFunction r) ptr
advancePtrState :: forall a ptr r.
(C a, Value (Ptr a) ~ ptr) =>
StateT ptr (CodeGenFunction r) ptr
advancePtrState = (ptr -> CodeGenFunction r ptr)
-> StateT ptr (CodeGenFunction r) ptr
forall (m :: * -> *) a. Monad m => (a -> m a) -> StateT a m a
update ((ptr -> CodeGenFunction r ptr)
 -> StateT ptr (CodeGenFunction r) ptr)
-> (ptr -> CodeGenFunction r ptr)
-> StateT ptr (CodeGenFunction r) ptr
forall a b. (a -> b) -> a -> b
$ Int -> ptr -> CodeGenFunction r ptr
forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
Int -> ptr -> CodeGenFunction r ptr
advancePtrStatic Int
1

advancePtr ::
   (Store.Storable a, Value (Ptr a) ~ ptr) =>
   Value Int -> ptr -> CodeGenFunction r ptr
advancePtr :: forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
Value Int -> ptr -> CodeGenFunction r ptr
advancePtr Value Int
n ptr
ptr = do
   Value Int
size <- Value Int -> Value Int -> CodeGenFunction r (Value Int)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.mul Value Int
n (Value Int -> CodeGenFunction r (Value Int))
-> Value Int -> CodeGenFunction r (Value Int)
forall a b. (a -> b) -> a -> b
$ Int -> Value Int
forall a. IsConst a => a -> Value a
LLVM.valueOf (Int -> Value Int) -> Int -> Value Int
forall a b. (a -> b) -> a -> b
$ a -> Int
forall a. Storable a => a -> Int
Store.sizeOf (Value (Ptr a) -> a
forall a. Value (Ptr a) -> a
elementFromPtr ptr
Value (Ptr a)
ptr)
   Value Int -> Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
forall a r.
Value Int -> Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
addPointer Value Int
size ptr
Value (Ptr a)
ptr

advancePtrStatic ::
   (Store.Storable a, Value (Ptr a) ~ ptr) =>
   Int -> ptr -> CodeGenFunction r ptr
advancePtrStatic :: forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
Int -> ptr -> CodeGenFunction r ptr
advancePtrStatic Int
n ptr
ptr =
   Value Int -> Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
forall a r.
Value Int -> Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
addPointer (Int -> Value Int
forall a. IsConst a => a -> Value a
LLVM.valueOf (a -> Int
forall a. Storable a => a -> Int
Store.sizeOf (Value (Ptr a) -> a
forall a. Value (Ptr a) -> a
elementFromPtr ptr
Value (Ptr a)
ptr) Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
n)) ptr
Value (Ptr a)
ptr

incrementPtr ::
   (Store.Storable a, Value (Ptr a) ~ ptr) =>
   ptr -> CodeGenFunction r ptr
incrementPtr :: forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
ptr -> CodeGenFunction r ptr
incrementPtr = Int -> ptr -> CodeGenFunction r ptr
forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
Int -> ptr -> CodeGenFunction r ptr
advancePtrStatic Int
1

decrementPtr ::
   (Store.Storable a, Value (Ptr a) ~ ptr) =>
   ptr -> CodeGenFunction r ptr
decrementPtr :: forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
ptr -> CodeGenFunction r ptr
decrementPtr = Int -> ptr -> CodeGenFunction r ptr
forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
Int -> ptr -> CodeGenFunction r ptr
advancePtrStatic (-Int
1)

addPointer :: Value Int -> Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
addPointer :: forall a r.
Value Int -> Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
addPointer Value Int
k Value (Ptr a)
ptr = do
   BytePtr
bytePtr <- Value (Ptr a) -> CodeGenFunction r BytePtr
forall a r. Value (Ptr a) -> CodeGenFunction r BytePtr
castToBytePtr Value (Ptr a)
ptr
   BytePtr -> CodeGenFunction r (Value (Ptr a))
forall r a. BytePtr -> CodeGenFunction r (Value (Ptr a))
castFromBytePtr (BytePtr -> CodeGenFunction r (Value (Ptr a)))
-> CodeGenFunction r BytePtr -> CodeGenFunction r (Value (Ptr a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< BytePtr
-> (Value Int, ())
-> CodeGenFunction r (Value (Ptr (ElementPtrType Word8 ())))
forall a o i r.
(GetElementPtr o i, IsType o, IsIndexArg a) =>
Value (Ptr o)
-> (a, i) -> CodeGenFunction r (Value (Ptr (ElementPtrType o i)))
LLVM.getElementPtr BytePtr
bytePtr (Value Int
k, ())

type BytePtr = Value (LLVM.Ptr Word8)

castToBytePtr :: Value (Ptr a) -> CodeGenFunction r BytePtr
castToBytePtr :: forall a r. Value (Ptr a) -> CodeGenFunction r BytePtr
castToBytePtr = Value (Ptr a) -> CodeGenFunction r BytePtr
forall (value :: * -> *) a b r.
(ValueCons value, IsSized a, IsSized b, SizeOf a ~ SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.bitcast

castFromBytePtr :: BytePtr -> CodeGenFunction r (Value (Ptr a))
castFromBytePtr :: forall r a. BytePtr -> CodeGenFunction r (Value (Ptr a))
castFromBytePtr = BytePtr -> CodeGenFunction r (Value (Ptr a))
forall (value :: * -> *) a b r.
(ValueCons value, IsSized a, IsSized b, SizeOf a ~ SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.bitcast

castElementPtr :: Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
castElementPtr :: forall (f :: * -> *) a r.
Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
castElementPtr = Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
forall (value :: * -> *) a b r.
(ValueCons value, IsSized a, IsSized b, SizeOf a ~ SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.bitcast


sizeOf :: (Store.Storable a) => LP.Proxy a -> Int
sizeOf :: forall a. Storable a => Proxy a -> Int
sizeOf = a -> Int
forall a. Storable a => a -> Int
Store.sizeOf (a -> Int) -> (Proxy a -> a) -> Proxy a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy a -> a
forall a. Proxy a -> a
elementFromProxy

elementFromPtr :: LLVM.Value (Ptr a) -> a
elementFromPtr :: forall a. Value (Ptr a) -> a
elementFromPtr Value (Ptr a)
_ = [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"elementFromProxy"

elementFromProxy :: LP.Proxy a -> a
elementFromProxy :: forall a. Proxy a -> a
elementFromProxy Proxy a
LP.Proxy = [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"elementFromProxy"

proxyFromElement2 :: f (g a) -> LP.Proxy a
proxyFromElement2 :: forall (f :: * -> *) (g :: * -> *) a. f (g a) -> Proxy a
proxyFromElement2 f (g a)
_ = Proxy a
forall a. Proxy a
LP.Proxy

proxyFromElement3 :: f (g (h a)) -> LP.Proxy a
proxyFromElement3 :: forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 f (g (h a))
_ = Proxy a
forall a. Proxy a
LP.Proxy