{-# LANGUAGE TypeFamilies #-}
module Synthesizer.LLVM.Generator.Source where

import qualified Synthesizer.LLVM.Storable.ChunkIterator as ChunkIt
import qualified Synthesizer.LLVM.Storable.LazySizeIterator as SizeIt
import qualified Synthesizer.LLVM.Generator.Private as Sig
import qualified Synthesizer.LLVM.ConstantPiece as Const
import qualified Synthesizer.LLVM.EventIterator as EventIt
import Synthesizer.LLVM.Private (noLocalPtr)

import qualified LLVM.DSL.Expression as Expr
import LLVM.DSL.Expression (Exp)

import qualified LLVM.Extra.Multi.Value.Storable as Storable
import qualified LLVM.Extra.Multi.Value.Marshal as Marshal
import qualified LLVM.Extra.Multi.Value as MultiValue
import qualified LLVM.Extra.MaybeContinuation as MaybeCont
import qualified LLVM.Extra.Memory as Memory
import qualified LLVM.Extra.Arithmetic as A
import qualified LLVM.Extra.Control as C

import qualified LLVM.Core as LLVM

import Foreign.Storable (Storable)
import Foreign.StablePtr (StablePtr)
import Foreign.Ptr (Ptr, nullPtr)

import Control.Applicative (liftA2, (<$>))

import Data.Tuple.HT (mapSnd)
import Data.Word (Word)


type T a = Sig.T (MultiValue.T a)


data StorableVector a = StorableVector (Ptr a) Word

storableVectorLength :: Exp (StorableVector a) -> Exp Word
storableVectorLength :: forall a. Exp (StorableVector a) -> Exp Word
storableVectorLength = (T (StorableVector a) -> T Word)
-> Exp (StorableVector a) -> Exp Word
forall a b. (T a -> T b) -> Exp a -> Exp b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
Expr.lift1 ((Repr (StorableVector a) -> Repr Word)
-> T (StorableVector a) -> T Word
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 (\(Value (Ptr a)
_ptr,Value Word
l) -> Repr Word
Value Word
l))

consStorableVector :: Ptr a -> Int -> StorableVector a
consStorableVector :: forall a. Ptr a -> Int -> StorableVector a
consStorableVector Ptr a
p = Ptr a -> Word -> StorableVector a
forall a. Ptr a -> Word -> StorableVector a
StorableVector Ptr a
p (Word -> StorableVector a)
-> (Int -> Word) -> Int -> StorableVector a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral

instance (Storable a) => MultiValue.C (StorableVector a) where
   type Repr (StorableVector a) = (LLVM.Value (Ptr a), LLVM.Value Word)
   cons :: StorableVector a -> T (StorableVector a)
cons (StorableVector Ptr a
p Word
l) = Repr (StorableVector a) -> T (StorableVector a)
forall a. Repr a -> T a
MultiValue.Cons (Ptr a -> Value (Ptr a)
forall a. IsConst a => a -> Value a
LLVM.valueOf Ptr a
p, Word -> Value Word
forall a. IsConst a => a -> Value a
LLVM.valueOf Word
l)
   undef :: T (StorableVector a)
undef = T (StorableVector a)
forall a al. (Repr a ~ al, Undefined al) => T a
MultiValue.undefTuple
   zero :: T (StorableVector a)
zero = T (StorableVector a)
forall a al. (Repr a ~ al, Zero al) => T a
MultiValue.zeroTuple
   phi :: forall r.
BasicBlock
-> T (StorableVector a) -> CodeGenFunction r (T (StorableVector a))
phi = BasicBlock
-> T (StorableVector a) -> CodeGenFunction r (T (StorableVector a))
forall a al r.
(Repr a ~ al, Phi al) =>
BasicBlock -> T a -> CodeGenFunction r (T a)
MultiValue.phiTuple
   addPhi :: forall r.
BasicBlock
-> T (StorableVector a)
-> T (StorableVector a)
-> CodeGenFunction r ()
addPhi = BasicBlock
-> T (StorableVector a)
-> T (StorableVector a)
-> CodeGenFunction r ()
forall a al r.
(Repr a ~ al, Phi al) =>
BasicBlock -> T a -> T a -> CodeGenFunction r ()
MultiValue.addPhiTuple

instance (Storable a) => Marshal.C (StorableVector a) where
   pack :: StorableVector a -> Struct (StorableVector a)
pack (StorableVector Ptr a
p Word
l) = Ptr a -> Word -> Struct (Ptr a, (Word, ()))
forall f. (ConsStruct f, ConsResult f ~ PartialStruct f) => f
LLVM.consStruct Ptr a
p Word
l
   unpack :: Struct (StorableVector a) -> StorableVector a
unpack = Curried (Ptr a, (Word, ())) (StorableVector a)
-> Struct (Ptr a, (Word, ())) -> StorableVector a
forall a b. CurryStruct a => Curried a b -> Struct a -> b
LLVM.uncurryStruct Curried (Ptr a, (Word, ())) (StorableVector a)
Ptr a -> Word -> StorableVector a
forall a. Ptr a -> Word -> StorableVector a
StorableVector

storableVector :: (Storable.C a) => Exp (StorableVector a) -> T a
storableVector :: forall a. C a => Exp (StorableVector a) -> T a
storableVector Exp (StorableVector a)
vec =
   (forall r c.
 Phi c =>
 Value (Ptr (Struct ()))
 -> (Value (Ptr a), Value Word)
 -> T r c (T a, (Value (Ptr a), Value Word)))
-> (forall r. CodeGenFunction r (Value (Ptr a), Value Word))
-> T (T a)
forall local state a.
(IsSized local, C state) =>
(forall r c.
 Phi c =>
 Value (Ptr local) -> state -> T r c (a, state))
-> (forall r. CodeGenFunction r state) -> T a
Sig.noGlobal
      (((Value (Ptr a), Value Word)
 -> T r c (T a, (Value (Ptr a), Value Word)))
-> Value (Ptr (Struct ()))
-> (Value (Ptr a), Value Word)
-> T r c (T a, (Value (Ptr a), Value Word))
forall f. f -> Value (Ptr (Struct ())) -> f
noLocalPtr (((Value (Ptr a), Value Word)
  -> T r c (T a, (Value (Ptr a), Value Word)))
 -> Value (Ptr (Struct ()))
 -> (Value (Ptr a), Value Word)
 -> T r c (T a, (Value (Ptr a), Value Word)))
-> ((Value (Ptr a), Value Word)
    -> T r c (T a, (Value (Ptr a), Value Word)))
-> Value (Ptr (Struct ()))
-> (Value (Ptr a), Value Word)
-> T r c (T a, (Value (Ptr a), Value Word))
forall a b. (a -> b) -> a -> b
$ \(Value (Ptr a)
p0,Value Word
l0) -> do
         Value Bool
cont <- CodeGenFunction r (Value Bool) -> T r c (Value Bool)
forall r a z. CodeGenFunction r a -> T r z a
MaybeCont.lift (CodeGenFunction r (Value Bool) -> T r c (Value Bool))
-> CodeGenFunction r (Value Bool) -> T r c (Value Bool)
forall a b. (a -> b) -> a -> b
$ CmpPredicate
-> Value Word
-> Value Word
-> CodeGenFunction r (CmpResult (Value Word))
forall r.
CmpPredicate
-> Value Word
-> Value Word
-> CodeGenFunction r (CmpResult (Value Word))
forall a r.
Comparison a =>
CmpPredicate -> a -> a -> CodeGenFunction r (CmpResult a)
A.cmp CmpPredicate
LLVM.CmpGT Value Word
l0 Value Word
forall a. Additive a => a
A.zero
         Value Bool
-> CodeGenFunction r (T a, (Value (Ptr a), Value Word))
-> T r c (T a, (Value (Ptr a), Value Word))
forall z r a. Phi z => Value Bool -> CodeGenFunction r a -> T r z a
MaybeCont.withBool Value Bool
cont (CodeGenFunction r (T a, (Value (Ptr a), Value Word))
 -> T r c (T a, (Value (Ptr a), Value Word)))
-> CodeGenFunction r (T a, (Value (Ptr a), Value Word))
-> T r c (T a, (Value (Ptr a), Value Word))
forall a b. (a -> b) -> a -> b
$ do
            T a
y1 <- Value (Ptr a) -> CodeGenFunction r (T a)
forall a r. C a => Value (Ptr a) -> CodeGenFunction r (T a)
forall r. Value (Ptr a) -> CodeGenFunction r (T a)
Storable.load Value (Ptr a)
p0
            Value (Ptr a)
p1 <- Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
ptr -> CodeGenFunction r ptr
Storable.incrementPtr Value (Ptr a)
p0
            Value Word
l1 <- Value Word -> CodeGenFunction r (Value Word)
forall a r.
(IsArithmetic a, IsConst a, Num a) =>
Value a -> CodeGenFunction r (Value a)
A.dec Value Word
l0
            (T a, (Value (Ptr a), Value Word))
-> CodeGenFunction r (T a, (Value (Ptr a), Value Word))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (T a
y1,(Value (Ptr a)
p1,Value Word
l1)))
      ((T (StorableVector a) -> (Value (Ptr a), Value Word))
-> CodeGenFunction r (T (StorableVector a))
-> CodeGenFunction r (Value (Ptr a), Value Word)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(MultiValue.Cons (Value (Ptr a)
p,Value Word
l)) -> (Value (Ptr a)
p,Value Word
l)) (Exp (StorableVector a)
-> forall r. CodeGenFunction r (T (StorableVector a))
forall a. Exp a -> forall r. CodeGenFunction r (T a)
Expr.unExp Exp (StorableVector a)
vec))


{-
This function calls back into the Haskell function 'ChunkIt.next'
that returns a pointer to the data of the next chunk
and advances to the next chunk in the sequence.
-}
storableVectorLazy ::
   (Storable.C a) => Exp (StablePtr (ChunkIt.T a)) -> T a
storableVectorLazy :: forall a. C a => Exp (StablePtr (T a)) -> T a
storableVectorLazy = T (Chunk a) -> T a
forall a. C a => T (Chunk a) -> T a
flattenChunks (T (Chunk a) -> T a)
-> (Exp (StablePtr (T a)) -> T (Chunk a))
-> Exp (StablePtr (T a))
-> T a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp (StablePtr (T a)) -> T (Chunk a)
forall a. C a => Exp (StablePtr (T a)) -> T (Chunk a)
storableVectorChunks

type Chunk a = (LLVM.Value (Ptr a), LLVM.Value Word)

storableVectorChunks ::
   (Storable.C a) => Exp (StablePtr (ChunkIt.T a)) -> Sig.T (Chunk a)
storableVectorChunks :: forall a. C a => Exp (StablePtr (T a)) -> T (Chunk a)
storableVectorChunks Exp (StablePtr (T a))
sig =
   (forall r c.
 Phi c =>
 Value (StablePtr (T a))
 -> Value (Ptr Word) -> () -> T r c (Chunk a, ()))
-> (forall r. CodeGenFunction r (Value (StablePtr (T a)), ()))
-> (forall r. Value (StablePtr (T a)) -> CodeGenFunction r ())
-> T (Chunk a)
forall a global local state.
(C global, IsSized local, C state) =>
(forall r c.
 Phi c =>
 global -> Value (Ptr local) -> state -> T r c (a, state))
-> (forall r. CodeGenFunction r (global, state))
-> (forall r. global -> CodeGenFunction r ())
-> T a
Sig.Cons
      (\Value (StablePtr (T a))
stable Value (Ptr Word)
lenPtr () -> CodeGenFunction r (Value Bool, (Chunk a, ()))
-> T r c (Chunk a, ())
forall z r a. Phi z => CodeGenFunction r (Value Bool, a) -> T r z a
MaybeCont.fromBool (CodeGenFunction r (Value Bool, (Chunk a, ()))
 -> T r c (Chunk a, ()))
-> CodeGenFunction r (Value Bool, (Chunk a, ()))
-> T r c (Chunk a, ())
forall a b. (a -> b) -> a -> b
$ do
         Function (StablePtr (T a) -> Ptr Word -> IO (Ptr a))
nextChunkFn <-
            String
-> FunPtr (StablePtr (T a) -> Ptr Word -> IO (Ptr a))
-> CodeGenFunction
     r (Function (StablePtr (T a) -> Ptr Word -> IO (Ptr a)))
forall f r.
IsFunction f =>
String -> FunPtr f -> CodeGenFunction r (Function f)
LLVM.staticNamedFunction
               String
"SignalExp.fromStorableVectorLazy.nextChunk"
               FunPtr (StablePtr (T a) -> Ptr Word -> IO (Ptr a))
forall a. FunPtr (StablePtr (T a) -> Ptr Word -> IO (Ptr a))
ChunkIt.nextCallBack
         (Value (Ptr a)
buffer,Value Word
len) <-
            (Value (Ptr a) -> Value Word -> Chunk a)
-> CodeGenFunction r (Value (Ptr a))
-> CodeGenFunction r (Value Word)
-> CodeGenFunction r (Chunk a)
forall a b c.
(a -> b -> c)
-> CodeGenFunction r a
-> CodeGenFunction r b
-> CodeGenFunction r c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (,)
               (Function (StablePtr (T a) -> Ptr Word -> IO (Ptr a))
-> Value (StablePtr (T a))
-> Value (Ptr Word)
-> CodeGenFunction r (Value (Ptr a))
forall r f g. CallArgs r f g => Function f -> g
LLVM.call Function (StablePtr (T a) -> Ptr Word -> IO (Ptr a))
nextChunkFn Value (StablePtr (T a))
stable Value (Ptr Word)
lenPtr)
               (Value (Ptr Word) -> CodeGenFunction r (Value Word)
forall a r. Value (Ptr a) -> CodeGenFunction r (Value a)
LLVM.load Value (Ptr Word)
lenPtr)
         Value Bool
valid <- CmpPredicate
-> Value (Ptr a)
-> Value (Ptr a)
-> CodeGenFunction r (CmpResult (Value (Ptr a)))
forall r.
CmpPredicate
-> Value (Ptr a)
-> Value (Ptr a)
-> CodeGenFunction r (CmpResult (Value (Ptr a)))
forall a r.
Comparison a =>
CmpPredicate -> a -> a -> CodeGenFunction r (CmpResult a)
A.cmp CmpPredicate
LLVM.CmpNE Value (Ptr a)
buffer (Ptr a -> Value (Ptr a)
forall a. IsConst a => a -> Value a
LLVM.valueOf Ptr a
forall a. Ptr a
nullPtr)
         (Value Bool, (Chunk a, ()))
-> CodeGenFunction r (Value Bool, (Chunk a, ()))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (Value Bool
valid, ((Value (Ptr a)
buffer,Value Word
len), ())))
      ((T (StablePtr (T a)) -> (Value (StablePtr (T a)), ()))
-> CodeGenFunction r (T (StablePtr (T a)))
-> CodeGenFunction r (Value (StablePtr (T a)), ())
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(MultiValue.Cons Repr (StablePtr (T a))
it) -> (Repr (StablePtr (T a))
Value (StablePtr (T a))
it, ())) (CodeGenFunction r (T (StablePtr (T a)))
 -> CodeGenFunction r (Value (StablePtr (T a)), ()))
-> CodeGenFunction r (T (StablePtr (T a)))
-> CodeGenFunction r (Value (StablePtr (T a)), ())
forall a b. (a -> b) -> a -> b
$ Exp (StablePtr (T a))
-> forall r. CodeGenFunction r (T (StablePtr (T a)))
forall a. Exp a -> forall r. CodeGenFunction r (T a)
Expr.unExp Exp (StablePtr (T a))
sig)
      (\ Value (StablePtr (T a))
_it -> () -> CodeGenFunction r ()
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return ())

flattenChunks :: (Storable.C a) => Sig.T (Chunk a) -> T a
flattenChunks :: forall a. C a => T (Chunk a) -> T a
flattenChunks (Sig.Cons forall r c.
Phi c =>
global -> Value (Ptr local) -> state -> T r c (Chunk a, state)
next forall r. CodeGenFunction r (global, state)
start forall r. global -> CodeGenFunction r ()
stop) =
   (forall r c.
 Phi c =>
 global
 -> Value (Ptr local)
 -> (Chunk a, state)
 -> T r c (T a, (Chunk a, state)))
-> (forall r. CodeGenFunction r (global, (Chunk a, state)))
-> (forall r. global -> CodeGenFunction r ())
-> T (T a)
forall a global local state.
(C global, IsSized local, C state) =>
(forall r c.
 Phi c =>
 global -> Value (Ptr local) -> state -> T r c (a, state))
-> (forall r. CodeGenFunction r (global, state))
-> (forall r. global -> CodeGenFunction r ())
-> T a
Sig.Cons
      (\global
global Value (Ptr local)
local ((Value (Ptr a)
buffer0,Value Word
length0), state
state0) -> do
         ((Value (Ptr a)
buffer1,Value Word
length1), state
state1) <- CodeGenFunction r (Value Bool, (Chunk a, state))
-> T r c (Chunk a, state)
forall z r a. Phi z => CodeGenFunction r (Value Bool, a) -> T r z a
MaybeCont.fromBool (CodeGenFunction r (Value Bool, (Chunk a, state))
 -> T r c (Chunk a, state))
-> CodeGenFunction r (Value Bool, (Chunk a, state))
-> T r c (Chunk a, state)
forall a b. (a -> b) -> a -> b
$ do
            Value Bool
needNext <- CmpPredicate
-> Value Word
-> Value Word
-> CodeGenFunction r (CmpResult (Value Word))
forall r.
CmpPredicate
-> Value Word
-> Value Word
-> CodeGenFunction r (CmpResult (Value Word))
forall a r.
Comparison a =>
CmpPredicate -> a -> a -> CodeGenFunction r (CmpResult a)
A.cmp CmpPredicate
LLVM.CmpEQ Value Word
length0 Value Word
forall a. Additive a => a
A.zero
            Value Bool
-> (Value Bool, (Chunk a, state))
-> CodeGenFunction r (Value Bool, (Chunk a, state))
-> CodeGenFunction r (Value Bool, (Chunk a, state))
forall a r.
Phi a =>
Value Bool -> a -> CodeGenFunction r a -> CodeGenFunction r a
C.ifThen Value Bool
needNext
               (Bool -> Value Bool
forall a. IsConst a => a -> Value a
LLVM.valueOf Bool
True, ((Value (Ptr a)
buffer0,Value Word
length0), state
state0))
               (T r (Value Bool, (Chunk a, state)) (Chunk a, state)
-> CodeGenFunction r (Value Bool, (Chunk a, state))
forall a r.
Undefined a =>
T r (Value Bool, a) a -> CodeGenFunction r (Value Bool, a)
MaybeCont.toBool (T r (Value Bool, (Chunk a, state)) (Chunk a, state)
 -> CodeGenFunction r (Value Bool, (Chunk a, state)))
-> T r (Value Bool, (Chunk a, state)) (Chunk a, state)
-> CodeGenFunction r (Value Bool, (Chunk a, state))
forall a b. (a -> b) -> a -> b
$ global
-> Value (Ptr local)
-> state
-> T r (Value Bool, (Chunk a, state)) (Chunk a, state)
forall r c.
Phi c =>
global -> Value (Ptr local) -> state -> T r c (Chunk a, state)
next global
global Value (Ptr local)
local state
state0)
         CodeGenFunction r (T a, (Chunk a, state))
-> T r c (T a, (Chunk a, state))
forall r a z. CodeGenFunction r a -> T r z a
MaybeCont.lift (CodeGenFunction r (T a, (Chunk a, state))
 -> T r c (T a, (Chunk a, state)))
-> CodeGenFunction r (T a, (Chunk a, state))
-> T r c (T a, (Chunk a, state))
forall a b. (a -> b) -> a -> b
$ do
            T a
x <- Value (Ptr a) -> CodeGenFunction r (T a)
forall a r. C a => Value (Ptr a) -> CodeGenFunction r (T a)
forall r. Value (Ptr a) -> CodeGenFunction r (T a)
Storable.load Value (Ptr a)
buffer1
            Value (Ptr a)
buffer2 <- Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
ptr -> CodeGenFunction r ptr
Storable.incrementPtr Value (Ptr a)
buffer1
            Value Word
length2 <- Value Word -> CodeGenFunction r (Value Word)
forall a r.
(IsArithmetic a, IsConst a, Num a) =>
Value a -> CodeGenFunction r (Value a)
A.dec Value Word
length1
            (T a, (Chunk a, state))
-> CodeGenFunction r (T a, (Chunk a, state))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (T a
x, ((Value (Ptr a)
buffer2,Value Word
length2), state
state1)))
      ((state -> (Chunk a, state))
-> (global, state) -> (global, (Chunk a, state))
forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd ((,) (Ptr a -> Value (Ptr a)
forall a. IsConst a => a -> Value a
LLVM.valueOf Ptr a
forall a. Ptr a
nullPtr, Value Word
forall a. Additive a => a
A.zero)) ((global, state) -> (global, (Chunk a, state)))
-> CodeGenFunction r (global, state)
-> CodeGenFunction r (global, (Chunk a, state))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CodeGenFunction r (global, state)
forall r. CodeGenFunction r (global, state)
start)
      global -> CodeGenFunction r ()
forall r. global -> CodeGenFunction r ()
stop


eventList ::
   (Marshal.C a) =>
   Exp (StablePtr (EventIt.T a)) -> Sig.T (Const.T (MultiValue.T a))
eventList :: forall a. C a => Exp (StablePtr (T a)) -> T (T (T a))
eventList Exp (StablePtr (T a))
sig =
   (forall r c.
 Phi c =>
 Value (StablePtr (T a))
 -> Value (Ptr (Struct (Repr a))) -> () -> T r c (T (T a), ()))
-> (forall r. CodeGenFunction r (Value (StablePtr (T a)), ()))
-> (forall r. Value (StablePtr (T a)) -> CodeGenFunction r ())
-> T (T (T a))
forall a global local state.
(C global, IsSized local, C state) =>
(forall r c.
 Phi c =>
 global -> Value (Ptr local) -> state -> T r c (a, state))
-> (forall r. CodeGenFunction r (global, state))
-> (forall r. global -> CodeGenFunction r ())
-> T a
Sig.Cons
      -- FixMe: duplicate of ConstantPiece.piecewiseConstant
      (\Value (StablePtr (T a))
stable Value (Ptr (Struct (Repr a)))
yPtr () -> do
         Value Word
len <- CodeGenFunction r (Value Word) -> T r c (Value Word)
forall r a z. CodeGenFunction r a -> T r z a
MaybeCont.lift (CodeGenFunction r (Value Word) -> T r c (Value Word))
-> CodeGenFunction r (Value Word) -> T r c (Value Word)
forall a b. (a -> b) -> a -> b
$ do
            Function (StablePtr (T a) -> Ptr (Struct (Repr a)) -> IO Word)
nextFn <-
               String
-> FunPtr (StablePtr (T a) -> Ptr (Struct (Repr a)) -> IO Word)
-> CodeGenFunction
     r (Function (StablePtr (T a) -> Ptr (Struct (Repr a)) -> IO Word))
forall f r.
IsFunction f =>
String -> FunPtr f -> CodeGenFunction r (Function f)
LLVM.staticNamedFunction
                  String
"ConstantPiece.piecewiseConstant.nextChunk"
                  FunPtr (StablePtr (T a) -> Ptr (Struct (Repr a)) -> IO Word)
forall a. FunPtr (StablePtr (T a) -> MarshalPtr a -> IO Word)
EventIt.nextCallBack
            Function (StablePtr (T a) -> Ptr (Struct (Repr a)) -> IO Word)
-> Value (StablePtr (T a))
-> Value (Ptr (Struct (Repr a)))
-> CodeGenFunction r (Value Word)
forall r f g. CallArgs r f g => Function f -> g
LLVM.call Function (StablePtr (T a) -> Ptr (Struct (Repr a)) -> IO Word)
nextFn Value (StablePtr (T a))
stable Value (Ptr (Struct (Repr a)))
yPtr
         Value Bool -> T r c ()
forall z r. Phi z => Value Bool -> T r z ()
MaybeCont.guard (Value Bool -> T r c ()) -> T r c (Value Bool) -> T r c ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< CodeGenFunction r (Value Bool) -> T r c (Value Bool)
forall r a z. CodeGenFunction r a -> T r z a
MaybeCont.lift (CmpPredicate
-> Value Word
-> Value Word
-> CodeGenFunction r (CmpResult (Value Word))
forall r.
CmpPredicate
-> Value Word
-> Value Word
-> CodeGenFunction r (CmpResult (Value Word))
forall a r.
Comparison a =>
CmpPredicate -> a -> a -> CodeGenFunction r (CmpResult a)
A.cmp CmpPredicate
LLVM.CmpNE Value Word
len Value Word
forall a. Additive a => a
A.zero)
         T a
y <- CodeGenFunction r (T a) -> T r c (T a)
forall r a z. CodeGenFunction r a -> T r z a
MaybeCont.lift (CodeGenFunction r (T a) -> T r c (T a))
-> CodeGenFunction r (T a) -> T r c (T a)
forall a b. (a -> b) -> a -> b
$ Value (Ptr (Struct (T a))) -> CodeGenFunction r (T a)
forall llvmValue r.
C llvmValue =>
Value (Ptr (Struct llvmValue)) -> CodeGenFunction r llvmValue
forall r. Value (Ptr (Struct (T a))) -> CodeGenFunction r (T a)
Memory.load Value (Ptr (Struct (Repr a)))
Value (Ptr (Struct (T a)))
yPtr
         (T (T a), ()) -> T r c (T (T a), ())
forall a. a -> T r c a
forall (m :: * -> *) a. Monad m => a -> m a
return (Value Word -> T a -> T (T a)
forall a. Value Word -> a -> T a
Const.Cons Value Word
len T a
y, ()))
      ((T (StablePtr (T a)) -> (Value (StablePtr (T a)), ()))
-> CodeGenFunction r (T (StablePtr (T a)))
-> CodeGenFunction r (Value (StablePtr (T a)), ())
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(MultiValue.Cons Repr (StablePtr (T a))
it) -> (Repr (StablePtr (T a))
Value (StablePtr (T a))
it, ())) (CodeGenFunction r (T (StablePtr (T a)))
 -> CodeGenFunction r (Value (StablePtr (T a)), ()))
-> CodeGenFunction r (T (StablePtr (T a)))
-> CodeGenFunction r (Value (StablePtr (T a)), ())
forall a b. (a -> b) -> a -> b
$ Exp (StablePtr (T a))
-> forall r. CodeGenFunction r (T (StablePtr (T a)))
forall a. Exp a -> forall r. CodeGenFunction r (T a)
Expr.unExp Exp (StablePtr (T a))
sig)
      (\ Value (StablePtr (T a))
_it -> () -> CodeGenFunction r ()
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return ())

lazySize :: Exp (StablePtr SizeIt.T) -> Sig.T (Const.T ())
lazySize :: Exp (StablePtr T) -> T (T ())
lazySize Exp (StablePtr T)
size = (forall r c.
 Phi c =>
 Value (StablePtr T)
 -> Value (Ptr (Struct ())) -> () -> T r c (T (), ()))
-> (forall r. CodeGenFunction r (Value (StablePtr T), ()))
-> (forall r. Value (StablePtr T) -> CodeGenFunction r ())
-> T (T ())
forall a global local state.
(C global, IsSized local, C state) =>
(forall r c.
 Phi c =>
 global -> Value (Ptr local) -> state -> T r c (a, state))
-> (forall r. CodeGenFunction r (global, state))
-> (forall r. global -> CodeGenFunction r ())
-> T a
Sig.Cons
   (\Value (StablePtr T)
stable -> (() -> T r c (T (), ()))
-> Value (Ptr (Struct ())) -> () -> T r c (T (), ())
forall f. f -> Value (Ptr (Struct ())) -> f
noLocalPtr ((() -> T r c (T (), ()))
 -> Value (Ptr (Struct ())) -> () -> T r c (T (), ()))
-> (() -> T r c (T (), ()))
-> Value (Ptr (Struct ()))
-> ()
-> T r c (T (), ())
forall a b. (a -> b) -> a -> b
$ \() -> do
      Value Word
len <- CodeGenFunction r (Value Word) -> T r c (Value Word)
forall r a z. CodeGenFunction r a -> T r z a
MaybeCont.lift (CodeGenFunction r (Value Word) -> T r c (Value Word))
-> CodeGenFunction r (Value Word) -> T r c (Value Word)
forall a b. (a -> b) -> a -> b
$ do
         Function (StablePtr T -> IO Word)
nextFn <-
            String
-> FunPtr (StablePtr T -> IO Word)
-> CodeGenFunction r (Function (StablePtr T -> IO Word))
forall f r.
IsFunction f =>
String -> FunPtr f -> CodeGenFunction r (Function f)
LLVM.staticNamedFunction
               String
"ConstantPiece.lazySize.next"
               FunPtr (StablePtr T -> IO Word)
SizeIt.nextCallBack
         Function (StablePtr T -> IO Word)
-> Value (StablePtr T) -> CodeGenFunction r (Value Word)
forall r f g. CallArgs r f g => Function f -> g
LLVM.call Function (StablePtr T -> IO Word)
nextFn Value (StablePtr T)
stable
      Value Bool -> T r c ()
forall z r. Phi z => Value Bool -> T r z ()
MaybeCont.guard (Value Bool -> T r c ()) -> T r c (Value Bool) -> T r c ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< CodeGenFunction r (Value Bool) -> T r c (Value Bool)
forall r a z. CodeGenFunction r a -> T r z a
MaybeCont.lift (CmpPredicate
-> Value Word
-> Value Word
-> CodeGenFunction r (CmpResult (Value Word))
forall r.
CmpPredicate
-> Value Word
-> Value Word
-> CodeGenFunction r (CmpResult (Value Word))
forall a r.
Comparison a =>
CmpPredicate -> a -> a -> CodeGenFunction r (CmpResult a)
A.cmp CmpPredicate
LLVM.CmpNE Value Word
len Value Word
forall a. Additive a => a
A.zero)
      (T (), ()) -> T r c (T (), ())
forall a. a -> T r c a
forall (m :: * -> *) a. Monad m => a -> m a
return (Value Word -> () -> T ()
forall a. Value Word -> a -> T a
Const.Cons Value Word
len (), ()))
   ((T (StablePtr T) -> (Value (StablePtr T), ()))
-> CodeGenFunction r (T (StablePtr T))
-> CodeGenFunction r (Value (StablePtr T), ())
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(MultiValue.Cons Repr (StablePtr T)
it) -> (Repr (StablePtr T)
Value (StablePtr T)
it, ())) (CodeGenFunction r (T (StablePtr T))
 -> CodeGenFunction r (Value (StablePtr T), ()))
-> CodeGenFunction r (T (StablePtr T))
-> CodeGenFunction r (Value (StablePtr T), ())
forall a b. (a -> b) -> a -> b
$ Exp (StablePtr T) -> forall r. CodeGenFunction r (T (StablePtr T))
forall a. Exp a -> forall r. CodeGenFunction r (T a)
Expr.unExp Exp (StablePtr T)
size)
   (\ Value (StablePtr T)
_it -> () -> CodeGenFunction r ()
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return ())