{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE UndecidableInstances #-}
module Synthesizer.LLVM.Filter.SecondOrderCascade (
   causal, causalPacked,
   Parameter,
   ParameterValue(..),
   ParameterStruct,
   fixSize, constArray,
   ) where

import qualified Synthesizer.LLVM.Filter.SecondOrder as Filt2

import qualified Synthesizer.LLVM.Causal.Functional as Func
import qualified Synthesizer.LLVM.Causal.Private as Causal
import qualified Synthesizer.LLVM.Generator.Private as Sig

import qualified Synthesizer.LLVM.Frame.SerialVector.Class as Serial
import Synthesizer.Causal.Class (($<))

import qualified LLVM.Extra.Multi.Value.Marshal as Marshal
import qualified LLVM.Extra.Multi.Value as MultiValue
import qualified LLVM.Extra.Arithmetic as A
import qualified LLVM.Extra.Tuple as Tuple
import qualified LLVM.Extra.Memory as Memory

import qualified LLVM.Core as LLVM

import qualified Type.Data.Num.Decimal as TypeNum
import Type.Data.Num.Decimal.Number ((:*:))
import Type.Base.Proxy (Proxy)

import Data.Word (Word)

import Control.Arrow ((<<<), (^<<), (&&&), arr)

import NumericPrelude.Base


type Parameter n a = MultiValue.Array n (Filt2.Parameter a)
type ParameterStruct n a = Marshal.Struct (Parameter n a)

newtype ParameterValue n a =
   ParameterValue {forall n a. ParameterValue n a -> T (Parameter n a)
parameterValue :: MultiValue.T (Parameter n a)}
{-
Automatic deriving is not allowed even with GeneralizedNewtypeDeriving
because of IsSized constraint
and it would also be wrong for Functor and friends.
      deriving
         (Tuple.Phi, Tuple.Undefined, Tuple.Zero,
          Functor, App.Applicative, Fold.Foldable, Trav.Traversable)
-}

instance (TypeNum.Natural n, Marshal.C a) =>
      Tuple.Phi (ParameterValue n a) where
   phi :: forall r.
BasicBlock
-> ParameterValue n a -> CodeGenFunction r (ParameterValue n a)
phi BasicBlock
bb (ParameterValue T (Parameter n a)
r) = (T (Parameter n a) -> ParameterValue n a)
-> CodeGenFunction r (T (Parameter n a))
-> CodeGenFunction r (ParameterValue n 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 T (Parameter n a) -> ParameterValue n a
forall n a. T (Parameter n a) -> ParameterValue n a
ParameterValue (CodeGenFunction r (T (Parameter n a))
 -> CodeGenFunction r (ParameterValue n a))
-> CodeGenFunction r (T (Parameter n a))
-> CodeGenFunction r (ParameterValue n a)
forall a b. (a -> b) -> a -> b
$ BasicBlock
-> T (Parameter n a) -> CodeGenFunction r (T (Parameter n a))
forall a r. C a => BasicBlock -> T a -> CodeGenFunction r (T a)
forall r.
BasicBlock
-> T (Parameter n a) -> CodeGenFunction r (T (Parameter n a))
MultiValue.phi BasicBlock
bb T (Parameter n a)
r
   addPhi :: forall r.
BasicBlock
-> ParameterValue n a -> ParameterValue n a -> CodeGenFunction r ()
addPhi BasicBlock
bb (ParameterValue T (Parameter n a)
r) (ParameterValue T (Parameter n a)
r') = BasicBlock
-> T (Parameter n a) -> T (Parameter n a) -> CodeGenFunction r ()
forall a r. C a => BasicBlock -> T a -> T a -> CodeGenFunction r ()
forall r.
BasicBlock
-> T (Parameter n a) -> T (Parameter n a) -> CodeGenFunction r ()
MultiValue.addPhi BasicBlock
bb T (Parameter n a)
r T (Parameter n a)
r'

instance (TypeNum.Natural n, Marshal.C a) =>
      Tuple.Undefined (ParameterValue n a) where
   undef :: ParameterValue n a
undef = T (Parameter n a) -> ParameterValue n a
forall n a. T (Parameter n a) -> ParameterValue n a
ParameterValue T (Parameter n a)
forall a. C a => T a
MultiValue.undef

instance (TypeNum.Natural n, Marshal.C a) =>
      Tuple.Zero (ParameterValue n a) where
   zero :: ParameterValue n a
zero = T (Parameter n a) -> ParameterValue n a
forall n a. T (Parameter n a) -> ParameterValue n a
ParameterValue T (Parameter n a)
forall a. C a => T a
MultiValue.zero

instance (TypeNum.Natural n, Marshal.C a,
          TypeNum.Positive (n :*: LLVM.UnknownSize)) =>
      Memory.C (ParameterValue n a) where
   type Struct (ParameterValue n a) = ParameterStruct n a
   load :: forall r.
Value (Ptr (Struct (ParameterValue n a)))
-> CodeGenFunction r (ParameterValue n a)
load = (T (Parameter n a) -> ParameterValue n a)
-> Value (Ptr (Struct (T (Parameter n a))))
-> CodeGenFunction r (ParameterValue n a)
forall a llvmValue r.
C a =>
(a -> llvmValue)
-> Value (Ptr (Struct a)) -> CodeGenFunction r llvmValue
Memory.loadNewtype T (Parameter n a) -> ParameterValue n a
forall n a. T (Parameter n a) -> ParameterValue n a
ParameterValue
   store :: forall r.
ParameterValue n a
-> Value (Ptr (Struct (ParameterValue n a)))
-> CodeGenFunction r ()
store = (ParameterValue n a -> T (Parameter n a))
-> ParameterValue n a
-> Value (Ptr (Struct (T (Parameter n a))))
-> CodeGenFunction r ()
forall a llvmValue r.
C a =>
(llvmValue -> a)
-> llvmValue -> Value (Ptr (Struct a)) -> CodeGenFunction r ()
Memory.storeNewtype (\(ParameterValue T (Parameter n a)
k) -> T (Parameter n a)
k)
   decompose :: forall r.
Value (Struct (ParameterValue n a))
-> CodeGenFunction r (ParameterValue n a)
decompose = (T (Parameter n a) -> ParameterValue n a)
-> Value (Struct (T (Parameter n a)))
-> CodeGenFunction r (ParameterValue n a)
forall a llvmValue r.
C a =>
(a -> llvmValue) -> Value (Struct a) -> CodeGenFunction r llvmValue
Memory.decomposeNewtype T (Parameter n a) -> ParameterValue n a
forall n a. T (Parameter n a) -> ParameterValue n a
ParameterValue
   compose :: forall r.
ParameterValue n a
-> CodeGenFunction r (Value (Struct (ParameterValue n a)))
compose = (ParameterValue n a -> T (Parameter n a))
-> ParameterValue n a
-> CodeGenFunction r (Value (Struct (T (Parameter n a))))
forall a llvmValue r.
C a =>
(llvmValue -> a)
-> llvmValue -> CodeGenFunction r (Value (Struct a))
Memory.composeNewtype (\(ParameterValue T (Parameter n a)
k) -> T (Parameter n a)
k)

type instance Func.Arguments f (ParameterValue n a) = f (ParameterValue n a)
instance Func.MakeArguments (ParameterValue n a) where
   makeArgs :: forall (f :: * -> *).
Functor f =>
f (ParameterValue n a) -> Arguments f (ParameterValue n a)
makeArgs = f (ParameterValue n a) -> f (ParameterValue n a)
f (ParameterValue n a) -> Arguments f (ParameterValue n a)
forall a. a -> a
id


withSize ::
   (TypeNum.Natural n) =>
   (TypeNum.Singleton n -> process (ParameterValue n a, x) y) ->
   process (ParameterValue n a, x) y
withSize :: forall n (process :: * -> * -> *) a x y.
Natural n =>
(Singleton n -> process (ParameterValue n a, x) y)
-> process (ParameterValue n a, x) y
withSize Singleton n -> process (ParameterValue n a, x) y
f = Singleton n -> process (ParameterValue n a, x) y
f Singleton n
forall x. Integer x => Singleton x
TypeNum.singleton

fixSize ::
   Proxy n ->
   process (ParameterValue n a, x) y ->
   process (ParameterValue n a, x) y
fixSize :: forall n (process :: * -> * -> *) a x y.
Proxy n
-> process (ParameterValue n a, x) y
-> process (ParameterValue n a, x) y
fixSize Proxy n
_n = process (ParameterValue n a, x) y
-> process (ParameterValue n a, x) y
forall a. a -> a
id

constArray ::
   (TypeNum.Natural n, Marshal.C a) =>
   Proxy n -> [a] -> MultiValue.T (MultiValue.Array n a)
constArray :: forall n a. (Natural n, C a) => Proxy n -> [a] -> T (Array n a)
constArray Proxy n
_n = Array n a -> T (Array n a)
forall a. C a => a -> T a
MultiValue.cons (Array n a -> T (Array n a))
-> ([a] -> Array n a) -> [a] -> T (Array n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Array n a
forall n a. [a] -> Array n a
MultiValue.Array


causal ::
   (A.PseudoModule v, Memory.C v, A.Scalar v ~ MultiValue.T a,
    Marshal.C a, MultiValue.IntegerConstant a,
    TypeNum.Natural n, TypeNum.Positive (n :*: LLVM.UnknownSize)) =>
   Causal.T (ParameterValue n a, v) v
causal :: forall v a n.
(PseudoModule v, C v, Scalar v ~ T a, C a, IntegerConstant a,
 Natural n, Positive (n :*: UnknownSize)) =>
T (ParameterValue n a, v) v
causal = T (Parameter (T a), v) v -> T (ParameterValue n a, v) v
forall a v n.
(C a, Phi v, Undefined v, Natural n,
 Positive (n :*: UnknownSize)) =>
T (Parameter (T a), v) v -> T (ParameterValue n a, v) v
causalGen T (Parameter (T a), v) v
forall a v.
(a ~ Scalar v, PseudoModule v, IntegerConstant a, C v) =>
T (Parameter a, v) v
Filt2.causal

causalPacked ::
   (Marshal.C a, MultiValue.PseudoRing a, MultiValue.IntegerConstant a,
    Serial.Write v, Serial.Element v ~ MultiValue.T a,
    Memory.C v, A.PseudoRing v, A.IntegerConstant v,
    TypeNum.Natural n, TypeNum.Positive (n :*: LLVM.UnknownSize)) =>
   Causal.T (ParameterValue n a, v) v
causalPacked :: forall a v n.
(C a, PseudoRing a, IntegerConstant a, Write v, Element v ~ T a,
 C v, PseudoRing v, IntegerConstant v, Natural n,
 Positive (n :*: UnknownSize)) =>
T (ParameterValue n a, v) v
causalPacked = T (Parameter (T a), v) v -> T (ParameterValue n a, v) v
forall a v n.
(C a, Phi v, Undefined v, Natural n,
 Positive (n :*: UnknownSize)) =>
T (Parameter (T a), v) v -> T (ParameterValue n a, v) v
causalGen T (Parameter (T a), v) v
forall v a.
(Write v, Element v ~ a, C v, C a, IntegerConstant v,
 IntegerConstant a, PseudoRing v, PseudoRing a) =>
T (Parameter a, v) v
Filt2.causalPacked

causalGen ::
   (Marshal.C a, Tuple.Phi v, Tuple.Undefined v,
    TypeNum.Natural n, TypeNum.Positive (n :*: LLVM.UnknownSize)) =>
   Causal.T (Filt2.Parameter (MultiValue.T a), v) v ->
   Causal.T (ParameterValue n a, v) v
causalGen :: forall a v n.
(C a, Phi v, Undefined v, Natural n,
 Positive (n :*: UnknownSize)) =>
T (Parameter (T a), v) v -> T (ParameterValue n a, v) v
causalGen T (Parameter (T a), v) v
stage =
   (Singleton n -> T (ParameterValue n a, v) v)
-> T (ParameterValue n a, v) v
forall n (process :: * -> * -> *) a x y.
Natural n =>
(Singleton n -> process (ParameterValue n a, x) y)
-> process (ParameterValue n a, x) y
withSize ((Singleton n -> T (ParameterValue n a, v) v)
 -> T (ParameterValue n a, v) v)
-> (Singleton n -> T (ParameterValue n a, v) v)
-> T (ParameterValue n a, v) v
forall a b. (a -> b) -> a -> b
$ \Singleton n
n ->
      (Value Word, v) -> v
forall a b. (a, b) -> b
snd
      ((Value Word, v) -> v)
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (ParameterValue n a, v))
     (Value Word, v)
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (ParameterValue n a, v))
     v
forall (a :: * -> * -> *) c d b.
Arrow a =>
(c -> d) -> a b c -> a b d
^<<
      Exp Word
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     (Value Word, v)
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     (Value Word, v)
forall a c.
(Undefined a, Phi a) =>
Exp Word -> T (c, a) a -> T (c, a) a
Causal.replicateControlled
         (Singleton n -> Exp Word
forall n a. (Integer n, Num a) => Singleton n -> a
TypeNum.integralFromSingleton Singleton n
n)
         (T (Parameter (T a), v) v
-> T (Value (Ptr (ParameterStruct n a)), (Value Word, v))
     (Value Word, v)
forall n a v.
(Natural n, C a) =>
T (Parameter (T a), v) v
-> T (Value (Ptr (ParameterStruct n a)), (Value Word, v))
     (Value Word, v)
paramStage T (Parameter (T a), v) v
stage)
      T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
   (Value Word, v))
  (Value Word, v)
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (ParameterValue n a, v))
     (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (ParameterValue n a, v))
     (Value Word, v)
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
      (forall r.
 (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
  (ParameterValue n a, v))
 -> CodeGenFunction
      r
      (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
       (Value Word, v)))
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (ParameterValue n a, v))
     (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
forall a b. (forall r. a -> CodeGenFunction r b) -> T a b
Causal.map
         (\(Value (Ptr (Array n (ParameterStruct (Struct (Repr a)))))
ptr, (ParameterValue n a
p,v
v)) -> do
            T (Parameter n a)
-> Value (Ptr (Struct (T (Parameter n a)))) -> CodeGenFunction r ()
forall r.
T (Parameter n a)
-> Value (Ptr (Struct (T (Parameter n a)))) -> CodeGenFunction r ()
forall llvmValue r.
C llvmValue =>
llvmValue -> Value (Ptr (Struct llvmValue)) -> CodeGenFunction r ()
Memory.store (ParameterValue n a -> T (Parameter n a)
forall n a. ParameterValue n a -> T (Parameter n a)
parameterValue ParameterValue n a
p) Value (Ptr (Struct (T (Parameter n a))))
Value (Ptr (Array n (ParameterStruct (Struct (Repr a)))))
ptr
            (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
 (Value Word, v))
-> CodeGenFunction
     r
     (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (Value (Ptr (Array n (ParameterStruct (Struct (Repr a)))))
ptr, (Value Word
forall a. Additive a => a
A.zero, v
v)))
      T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
   (ParameterValue n a, v))
  v
-> SignalOf
     T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))))
-> T (ParameterValue n a, v) v
forall (process :: * -> * -> *) a b c.
C process =>
process (a, b) c -> SignalOf process a -> process b c
$<
      SignalOf
  T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))))
T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))))
forall a. IsSized a => T (Value (Ptr a))
Sig.alloca

paramStage ::
   (TypeNum.Natural n, Marshal.C a) =>
   Causal.T (Filt2.Parameter (MultiValue.T a), v) v ->
   Causal.T
      (LLVM.Value (LLVM.Ptr (ParameterStruct n a)), (LLVM.Value Word, v))
      (LLVM.Value Word, v)
paramStage :: forall n a v.
(Natural n, C a) =>
T (Parameter (T a), v) v
-> T (Value (Ptr (ParameterStruct n a)), (Value Word, v))
     (Value Word, v)
paramStage T (Parameter (T a), v) v
stage =
   let p :: T (c, b) c
p = ((c, b) -> c) -> T (c, b) c
forall b c. (b -> c) -> T b c
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr (c, b) -> c
forall a b. (a, b) -> a
fst
       i :: T (a, (c, b)) c
i = ((a, (c, b)) -> c) -> T (a, (c, b)) c
forall b c. (b -> c) -> T b c
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr ((c, b) -> c
forall a b. (a, b) -> a
fst((c, b) -> c) -> ((a, (c, b)) -> (c, b)) -> (a, (c, b)) -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(a, (c, b)) -> (c, b)
forall a b. (a, b) -> b
snd)
       v :: T (a, (a, c)) c
v = ((a, (a, c)) -> c) -> T (a, (a, c)) c
forall b c. (b -> c) -> T b c
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr ((a, c) -> c
forall a b. (a, b) -> b
snd((a, c) -> c) -> ((a, (a, c)) -> (a, c)) -> (a, (a, c)) -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(a, (a, c)) -> (a, c)
forall a b. (a, b) -> b
snd)
   in  ((forall r. Value Word -> CodeGenFunction r (Value Word))
-> T (Value Word) (Value Word)
forall a b. (forall r. a -> CodeGenFunction r b) -> T a b
Causal.map Value Word -> CodeGenFunction r (Value Word)
forall r. Value Word -> CodeGenFunction r (Value Word)
forall a r.
(IsArithmetic a, IsConst a, Num a) =>
Value a -> CodeGenFunction r (Value a)
A.inc T (Value Word) (Value Word)
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     (Value Word)
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     (Value Word)
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<< T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
   (Value Word, v))
  (Value Word)
forall {a} {c} {b}. T (a, (c, b)) c
i)
       T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
   (Value Word, v))
  (Value Word)
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     v
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     (Value Word, v)
forall b c c'. T b c -> T b c' -> T b (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&&
       (T (Parameter (T a), v) v
stage T (Parameter (T a), v) v
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     (Parameter (T a), v)
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     v
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
           ((forall r.
 Value (Ptr (Array n (ParameterStruct (Struct (Repr a)))))
 -> Value Word -> CodeGenFunction r (Parameter (T a)))
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      Value Word)
     (Parameter (T a))
forall a b c.
(forall r. a -> b -> CodeGenFunction r c) -> T (a, b) c
Causal.zipWith Value (Ptr (Struct (Repr (Array n (Parameter a)))))
-> Value Word -> CodeGenFunction r (Parameter (T a))
Value (Ptr (Array n (ParameterStruct (Struct (Repr a)))))
-> Value Word -> CodeGenFunction r (Parameter (T a))
forall r.
Value (Ptr (Array n (ParameterStruct (Struct (Repr a)))))
-> Value Word -> CodeGenFunction r (Parameter (T a))
forall n a r.
(Natural n, C a) =>
Value (Ptr (ParameterStruct n a))
-> Value Word -> CodeGenFunction r (Parameter (T a))
getStageParameterGEP T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
   Value Word)
  (Parameter (T a))
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      Value Word)
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     (Parameter (T a))
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<< T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
   (Value Word, v))
  (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))))
forall {c} {b}. T (c, b) c
p T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
   (Value Word, v))
  (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))))
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     (Value Word)
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      Value Word)
forall b c c'. T b c -> T b c' -> T b (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
   (Value Word, v))
  (Value Word)
forall {a} {c} {b}. T (a, (c, b)) c
i)
           T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
   (Value Word, v))
  (Parameter (T a))
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     v
-> T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
      (Value Word, v))
     (Parameter (T a), v)
forall b c c'. T b c -> T b c' -> T b (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&&
           T (Value (Ptr (Array n (ParameterStruct (Struct (Repr a))))),
   (Value Word, v))
  v
forall {a} {a} {c}. T (a, (a, c)) c
v)

getStageParameterGEP ::
   (TypeNum.Natural n,  Marshal.C a) =>
   LLVM.Value (LLVM.Ptr (ParameterStruct n a)) ->
   LLVM.Value Word ->
   LLVM.CodeGenFunction r (Filt2.Parameter (MultiValue.T a))
getStageParameterGEP :: forall n a r.
(Natural n, C a) =>
Value (Ptr (ParameterStruct n a))
-> Value Word -> CodeGenFunction r (Parameter (T a))
getStageParameterGEP Value (Ptr (ParameterStruct n a))
ptr Value Word
k =
   Value (Struct (Parameter a)) -> CodeGenFunction r (Parameter (T a))
Value (ParameterStruct (Struct (Repr a)))
-> CodeGenFunction r (Parameter (T a))
forall a r.
C a =>
Value (Struct (Parameter a)) -> CodeGenFunction r (Parameter (T a))
Filt2.decomposeParameterMV
    (Value (ParameterStruct (Struct (Repr a)))
 -> CodeGenFunction r (Parameter (T a)))
-> CodeGenFunction r (Value (ParameterStruct (Struct (Repr a))))
-> CodeGenFunction r (Parameter (T a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr (ParameterStruct (Struct (Repr a))))
-> CodeGenFunction r (Value (ParameterStruct (Struct (Repr a))))
forall a r. Value (Ptr a) -> CodeGenFunction r (Value a)
LLVM.load
    (Value (Ptr (ParameterStruct (Struct (Repr a))))
 -> CodeGenFunction r (Value (ParameterStruct (Struct (Repr a)))))
-> CodeGenFunction
     r (Value (Ptr (ParameterStruct (Struct (Repr a)))))
-> CodeGenFunction r (Value (ParameterStruct (Struct (Repr a))))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr (Array n (ParameterStruct (Struct (Repr a)))))
-> (Value Word, ())
-> CodeGenFunction
     r
     (Value
        (Ptr
           (ElementPtrType
              (Array n (ParameterStruct (Struct (Repr a)))) (Value Word, ()))))
forall o i r.
GetElementPtr o i =>
Value (Ptr o)
-> i -> CodeGenFunction r (Value (Ptr (ElementPtrType o i)))
LLVM.getElementPtr0 Value (Ptr (ParameterStruct n a))
Value (Ptr (Array n (ParameterStruct (Struct (Repr a)))))
ptr (Value Word
k, ())