{-# LANGUAGE FlexibleContexts    #-}
{-# LANGUAGE GADTs               #-}
{-# LANGUAGE RecordWildCards     #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications    #-}
{-# LANGUAGE TypeOperators       #-}
{-# LANGUAGE ViewPatterns        #-}
{-# OPTIONS_HADDOCK hide #-}
-- |
-- Module      : Data.Array.Accelerate.LLVM.CodeGen
-- Copyright   : [2015..2020] The Accelerate Team
-- License     : BSD3
--
-- Maintainer  : Trevor L. McDonell <trevor.mcdonell@gmail.com>
-- Stability   : experimental
-- Portability : non-portable (GHC extensions)
--

module Data.Array.Accelerate.LLVM.CodeGen (

  Skeleton(..), Intrinsic(..), KernelMetadata,
  llvmOfPreOpenAcc,

) where

import Data.Array.Accelerate.AST
import Data.Array.Accelerate.Error
import Data.Array.Accelerate.Representation.Array
import Data.Array.Accelerate.Representation.Type
import Data.Array.Accelerate.Representation.Stencil
import Data.Array.Accelerate.Trafo.Delayed

import Data.Array.Accelerate.LLVM.Target

import Data.Array.Accelerate.LLVM.CodeGen.Constant
import Data.Array.Accelerate.LLVM.CodeGen.Environment
import Data.Array.Accelerate.LLVM.CodeGen.Exp
import Data.Array.Accelerate.LLVM.CodeGen.Intrinsic
import Data.Array.Accelerate.LLVM.CodeGen.Module
import Data.Array.Accelerate.LLVM.CodeGen.Monad
import Data.Array.Accelerate.LLVM.CodeGen.Permute
import Data.Array.Accelerate.LLVM.CodeGen.Skeleton
import Data.Array.Accelerate.LLVM.CodeGen.Stencil
import Data.Array.Accelerate.LLVM.CodeGen.Sugar
import Data.Array.Accelerate.LLVM.Compile.Cache
import Data.Array.Accelerate.LLVM.Foreign
import Data.Array.Accelerate.LLVM.State

import Prelude                                                      hiding ( map, scanl, scanl1, scanr, scanr1 )


-- | Generate code for a given target architecture.
--
{-# INLINEABLE llvmOfPreOpenAcc #-}
llvmOfPreOpenAcc
    :: forall arch aenv arrs. (HasCallStack, Target arch, Skeleton arch, Intrinsic arch, Foreign arch)
    => UID
    -> PreOpenAcc DelayedOpenAcc aenv arrs
    -> Gamma aenv
    -> LLVM arch (Module arch aenv arrs)
llvmOfPreOpenAcc :: UID
-> PreOpenAcc DelayedOpenAcc aenv arrs
-> Gamma aenv
-> LLVM arch (Module arch aenv arrs)
llvmOfPreOpenAcc UID
uid PreOpenAcc DelayedOpenAcc aenv arrs
pacc Gamma aenv
aenv = CodeGen arch (IROpenAcc arch aenv arrs)
-> LLVM arch (Module arch aenv arrs)
forall arch aenv a.
(HasCallStack, Target arch, Intrinsic arch) =>
CodeGen arch (IROpenAcc arch aenv a)
-> LLVM arch (Module arch aenv a)
evalCodeGen (CodeGen arch (IROpenAcc arch aenv arrs)
 -> LLVM arch (Module arch aenv arrs))
-> CodeGen arch (IROpenAcc arch aenv arrs)
-> LLVM arch (Module arch aenv arrs)
forall a b. (a -> b) -> a -> b
$
  case PreOpenAcc DelayedOpenAcc aenv arrs
pacc of
    -- Producers
    Map TypeR e'
tp Fun aenv (e -> e')
f (DelayedOpenAcc aenv (Array sh e) -> ArrayR (Array sh e)
forall (f :: * -> * -> *) aenv sh e.
HasArraysR f =>
f aenv (Array sh e) -> ArrayR (Array sh e)
arrayR -> ArrayR (Array sh e)
repr)               -> UID
-> Gamma aenv
-> ArrayR (Array sh e)
-> TypeR e'
-> IRFun1 arch aenv (e -> e')
-> CodeGen arch (IROpenAcc arch aenv (Array sh e'))
forall arch aenv sh a b.
Skeleton arch =>
UID
-> Gamma aenv
-> ArrayR (Array sh a)
-> TypeR b
-> IRFun1 arch aenv (a -> b)
-> CodeGen arch (IROpenAcc arch aenv (Array sh b))
map UID
uid Gamma aenv
aenv ArrayR (Array sh e)
repr TypeR e'
tp (Fun aenv (e -> e') -> IRFun1 arch aenv (e -> e')
forall a b. Fun aenv (a -> b) -> IRFun1 arch aenv (a -> b)
travF1 Fun aenv (e -> e')
f)
    Generate ArrayR (Array sh e)
repr Exp aenv sh
_ Fun aenv (sh -> e)
f                       -> UID
-> Gamma aenv
-> ArrayR (Array sh e)
-> IRFun1 arch aenv (sh -> e)
-> CodeGen arch (IROpenAcc arch aenv (Array sh e))
forall arch aenv sh e.
Skeleton arch =>
UID
-> Gamma aenv
-> ArrayR (Array sh e)
-> IRFun1 arch aenv (sh -> e)
-> CodeGen arch (IROpenAcc arch aenv (Array sh e))
generate UID
uid Gamma aenv
aenv ArrayR (Array sh e)
repr (Fun aenv (sh -> e) -> IRFun1 arch aenv (sh -> e)
forall a b. Fun aenv (a -> b) -> IRFun1 arch aenv (a -> b)
travF1 Fun aenv (sh -> e)
f)
    Transform ArrayR (Array sh' b)
repr2 Exp aenv sh'
_ Fun aenv (sh' -> sh)
p Fun aenv (a1 -> b)
f (DelayedOpenAcc aenv (Array sh a1) -> ArrayR (Array sh a1)
forall (f :: * -> * -> *) aenv sh e.
HasArraysR f =>
f aenv (Array sh e) -> ArrayR (Array sh e)
arrayR -> ArrayR (Array sh a1)
repr1) -> UID
-> Gamma aenv
-> ArrayR (Array sh a1)
-> ArrayR (Array sh' b)
-> IRFun1 arch aenv (sh' -> sh)
-> IRFun1 arch aenv (a1 -> b)
-> CodeGen arch (IROpenAcc arch aenv (Array sh' b))
forall arch aenv sh a sh' b.
Skeleton arch =>
UID
-> Gamma aenv
-> ArrayR (Array sh a)
-> ArrayR (Array sh' b)
-> IRFun1 arch aenv (sh' -> sh)
-> IRFun1 arch aenv (a -> b)
-> CodeGen arch (IROpenAcc arch aenv (Array sh' b))
transform UID
uid Gamma aenv
aenv ArrayR (Array sh a1)
repr1 ArrayR (Array sh' b)
repr2 (Fun aenv (sh' -> sh) -> IRFun1 arch aenv (sh' -> sh)
forall a b. Fun aenv (a -> b) -> IRFun1 arch aenv (a -> b)
travF1 Fun aenv (sh' -> sh)
p) (Fun aenv (a1 -> b) -> IRFun1 arch aenv (a1 -> b)
forall a b. Fun aenv (a -> b) -> IRFun1 arch aenv (a -> b)
travF1 Fun aenv (a1 -> b)
f)
    Backpermute ShapeR sh'
shr Exp aenv sh'
_ Fun aenv (sh' -> sh)
p (DelayedOpenAcc aenv (Array sh e) -> ArrayR (Array sh e)
forall (f :: * -> * -> *) aenv sh e.
HasArraysR f =>
f aenv (Array sh e) -> ArrayR (Array sh e)
arrayR -> ArrayR (Array sh e)
repr)    -> UID
-> Gamma aenv
-> ArrayR (Array sh e)
-> ShapeR sh'
-> IRFun1 arch aenv (sh' -> sh)
-> CodeGen arch (IROpenAcc arch aenv (Array sh' e))
forall arch aenv sh e sh'.
Skeleton arch =>
UID
-> Gamma aenv
-> ArrayR (Array sh e)
-> ShapeR sh'
-> IRFun1 arch aenv (sh' -> sh)
-> CodeGen arch (IROpenAcc arch aenv (Array sh' e))
backpermute UID
uid Gamma aenv
aenv ArrayR (Array sh e)
repr ShapeR sh'
shr (Fun aenv (sh' -> sh) -> IRFun1 arch aenv (sh' -> sh)
forall a b. Fun aenv (a -> b) -> IRFun1 arch aenv (a -> b)
travF1 Fun aenv (sh' -> sh)
p)

    -- Consumers
    Fold Fun aenv (e -> e -> e)
f Maybe (Exp aenv e)
z DelayedOpenAcc aenv (Array (sh, Int) e)
a                              -> UID
-> Gamma aenv
-> ArrayR (Array sh e)
-> IRFun2 arch aenv (e -> e -> e)
-> Maybe (IRExp arch aenv e)
-> MIRDelayed arch aenv (Array (sh, Int) e)
-> CodeGen arch (IROpenAcc arch aenv (Array sh e))
forall arch aenv sh e.
Skeleton arch =>
UID
-> Gamma aenv
-> ArrayR (Array sh e)
-> IRFun2 arch aenv (e -> e -> e)
-> Maybe (IRExp arch aenv e)
-> MIRDelayed arch aenv (Array (sh, Int) e)
-> CodeGen arch (IROpenAcc arch aenv (Array sh e))
fold UID
uid Gamma aenv
aenv (ArrayR (Array (sh, Int) e) -> ArrayR (Array sh e)
forall sh e. ArrayR (Array (sh, Int) e) -> ArrayR (Array sh e)
reduceRank (ArrayR (Array (sh, Int) e) -> ArrayR (Array sh e))
-> ArrayR (Array (sh, Int) e) -> ArrayR (Array sh e)
forall a b. (a -> b) -> a -> b
$ DelayedOpenAcc aenv (Array (sh, Int) e)
-> ArrayR (Array (sh, Int) e)
forall (f :: * -> * -> *) aenv sh e.
HasArraysR f =>
f aenv (Array sh e) -> ArrayR (Array sh e)
arrayR DelayedOpenAcc aenv (Array (sh, Int) e)
a) (Fun aenv (e -> e -> e) -> IRFun2 arch aenv (e -> e -> e)
forall a b c.
Fun aenv (a -> b -> c) -> IRFun2 arch aenv (a -> b -> c)
travF2 Fun aenv (e -> e -> e)
f) (Exp aenv e -> IRExp arch aenv e
forall t. Exp aenv t -> IRExp arch aenv t
travE (Exp aenv e -> IRExp arch aenv e)
-> Maybe (Exp aenv e) -> Maybe (IRExp arch aenv e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Exp aenv e)
z) (DelayedOpenAcc aenv (Array (sh, Int) e)
-> MIRDelayed arch aenv (Array (sh, Int) e)
forall sh e.
DelayedOpenAcc aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
travD DelayedOpenAcc aenv (Array (sh, Int) e)
a)
    FoldSeg IntegralType i
i Fun aenv (e -> e -> e)
f Maybe (Exp aenv e)
z DelayedOpenAcc aenv (Array (sh, Int) e)
a DelayedOpenAcc aenv (Segments i)
s                       -> UID
-> Gamma aenv
-> ArrayR (Array (sh, Int) e)
-> IntegralType i
-> IRFun2 arch aenv (e -> e -> e)
-> Maybe (IRExp arch aenv e)
-> MIRDelayed arch aenv (Array (sh, Int) e)
-> MIRDelayed arch aenv (Segments i)
-> CodeGen arch (IROpenAcc arch aenv (Array (sh, Int) e))
forall arch aenv sh e i.
Skeleton arch =>
UID
-> Gamma aenv
-> ArrayR (Array (sh, Int) e)
-> IntegralType i
-> IRFun2 arch aenv (e -> e -> e)
-> Maybe (IRExp arch aenv e)
-> MIRDelayed arch aenv (Array (sh, Int) e)
-> MIRDelayed arch aenv (Segments i)
-> CodeGen arch (IROpenAcc arch aenv (Array (sh, Int) e))
foldSeg UID
uid Gamma aenv
aenv (DelayedOpenAcc aenv (Array (sh, Int) e)
-> ArrayR (Array (sh, Int) e)
forall (f :: * -> * -> *) aenv sh e.
HasArraysR f =>
f aenv (Array sh e) -> ArrayR (Array sh e)
arrayR DelayedOpenAcc aenv (Array (sh, Int) e)
a) IntegralType i
i (Fun aenv (e -> e -> e) -> IRFun2 arch aenv (e -> e -> e)
forall a b c.
Fun aenv (a -> b -> c) -> IRFun2 arch aenv (a -> b -> c)
travF2 Fun aenv (e -> e -> e)
f) (Exp aenv e -> IRExp arch aenv e
forall t. Exp aenv t -> IRExp arch aenv t
travE (Exp aenv e -> IRExp arch aenv e)
-> Maybe (Exp aenv e) -> Maybe (IRExp arch aenv e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Exp aenv e)
z) (DelayedOpenAcc aenv (Array (sh, Int) e)
-> MIRDelayed arch aenv (Array (sh, Int) e)
forall sh e.
DelayedOpenAcc aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
travD DelayedOpenAcc aenv (Array (sh, Int) e)
a) (DelayedOpenAcc aenv (Segments i)
-> MIRDelayed arch aenv (Segments i)
forall sh e.
DelayedOpenAcc aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
travD DelayedOpenAcc aenv (Segments i)
s)
    Scan Direction
d Fun aenv (e -> e -> e)
f Maybe (Exp aenv e)
z DelayedOpenAcc aenv (Array (sh, Int) e)
a                            -> UID
-> Gamma aenv
-> ArrayR (Array (sh, Int) e)
-> Direction
-> IRFun2 arch aenv (e -> e -> e)
-> Maybe (IRExp arch aenv e)
-> MIRDelayed arch aenv (Array (sh, Int) e)
-> CodeGen arch (IROpenAcc arch aenv (Array (sh, Int) e))
forall arch aenv sh e.
Skeleton arch =>
UID
-> Gamma aenv
-> ArrayR (Array (sh, Int) e)
-> Direction
-> IRFun2 arch aenv (e -> e -> e)
-> Maybe (IRExp arch aenv e)
-> MIRDelayed arch aenv (Array (sh, Int) e)
-> CodeGen arch (IROpenAcc arch aenv (Array (sh, Int) e))
scan UID
uid Gamma aenv
aenv (DelayedOpenAcc aenv (Array (sh, Int) e)
-> ArrayR (Array (sh, Int) e)
forall (f :: * -> * -> *) aenv sh e.
HasArraysR f =>
f aenv (Array sh e) -> ArrayR (Array sh e)
arrayR DelayedOpenAcc aenv (Array (sh, Int) e)
a) Direction
d (Fun aenv (e -> e -> e) -> IRFun2 arch aenv (e -> e -> e)
forall a b c.
Fun aenv (a -> b -> c) -> IRFun2 arch aenv (a -> b -> c)
travF2 Fun aenv (e -> e -> e)
f) (Exp aenv e -> IRExp arch aenv e
forall t. Exp aenv t -> IRExp arch aenv t
travE (Exp aenv e -> IRExp arch aenv e)
-> Maybe (Exp aenv e) -> Maybe (IRExp arch aenv e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Exp aenv e)
z) (DelayedOpenAcc aenv (Array (sh, Int) e)
-> MIRDelayed arch aenv (Array (sh, Int) e)
forall sh e.
DelayedOpenAcc aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
travD DelayedOpenAcc aenv (Array (sh, Int) e)
a)
    Scan' Direction
d Fun aenv (e -> e -> e)
f Exp aenv e
z DelayedOpenAcc aenv (Array (sh, Int) e)
a                           -> UID
-> Gamma aenv
-> ArrayR (Array (sh, Int) e)
-> Direction
-> IRFun2 arch aenv (e -> e -> e)
-> IRExp arch aenv e
-> MIRDelayed arch aenv (Array (sh, Int) e)
-> CodeGen
     arch (IROpenAcc arch aenv (Array (sh, Int) e, Array sh e))
forall arch aenv sh e.
Skeleton arch =>
UID
-> Gamma aenv
-> ArrayR (Array (sh, Int) e)
-> Direction
-> IRFun2 arch aenv (e -> e -> e)
-> IRExp arch aenv e
-> MIRDelayed arch aenv (Array (sh, Int) e)
-> CodeGen
     arch (IROpenAcc arch aenv (Array (sh, Int) e, Array sh e))
scan' UID
uid Gamma aenv
aenv (DelayedOpenAcc aenv (Array (sh, Int) e)
-> ArrayR (Array (sh, Int) e)
forall (f :: * -> * -> *) aenv sh e.
HasArraysR f =>
f aenv (Array sh e) -> ArrayR (Array sh e)
arrayR DelayedOpenAcc aenv (Array (sh, Int) e)
a) Direction
d (Fun aenv (e -> e -> e) -> IRFun2 arch aenv (e -> e -> e)
forall a b c.
Fun aenv (a -> b -> c) -> IRFun2 arch aenv (a -> b -> c)
travF2 Fun aenv (e -> e -> e)
f) (Exp aenv e -> IRExp arch aenv e
forall t. Exp aenv t -> IRExp arch aenv t
travE Exp aenv e
z) (DelayedOpenAcc aenv (Array (sh, Int) e)
-> MIRDelayed arch aenv (Array (sh, Int) e)
forall sh e.
DelayedOpenAcc aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
travD DelayedOpenAcc aenv (Array (sh, Int) e)
a)
    Permute Fun aenv (e -> e -> e)
f (DelayedOpenAcc aenv (Array sh' e) -> ArrayR (Array sh' e)
forall (f :: * -> * -> *) aenv sh e.
HasArraysR f =>
f aenv (Array sh e) -> ArrayR (Array sh e)
arrayR -> ArrayR ShapeR sh
shr TypeR e
_) Fun aenv (sh -> PrimMaybe sh')
p DelayedOpenAcc aenv (Array sh e)
a  -> UID
-> Gamma aenv
-> ArrayR (Array sh e)
-> ShapeR sh
-> IRPermuteFun arch aenv (e -> e -> e)
-> IRFun1 arch aenv (sh -> PrimMaybe sh)
-> MIRDelayed arch aenv (Array sh e)
-> CodeGen arch (IROpenAcc arch aenv (Array sh e))
forall arch aenv sh e sh'.
Skeleton arch =>
UID
-> Gamma aenv
-> ArrayR (Array sh e)
-> ShapeR sh'
-> IRPermuteFun arch aenv (e -> e -> e)
-> IRFun1 arch aenv (sh -> PrimMaybe sh')
-> MIRDelayed arch aenv (Array sh e)
-> CodeGen arch (IROpenAcc arch aenv (Array sh' e))
permute UID
uid Gamma aenv
aenv (DelayedOpenAcc aenv (Array sh e) -> ArrayR (Array sh e)
forall (f :: * -> * -> *) aenv sh e.
HasArraysR f =>
f aenv (Array sh e) -> ArrayR (Array sh e)
arrayR DelayedOpenAcc aenv (Array sh e)
a) ShapeR sh
shr (Fun aenv (e -> e -> e) -> IRPermuteFun arch aenv (e -> e -> e)
forall e.
Fun aenv (e -> e -> e) -> IRPermuteFun arch aenv (e -> e -> e)
travPF Fun aenv (e -> e -> e)
f) (Fun aenv (sh -> PrimMaybe sh')
-> IRFun1 arch aenv (sh -> PrimMaybe sh')
forall a b. Fun aenv (a -> b) -> IRFun1 arch aenv (a -> b)
travF1 Fun aenv (sh -> PrimMaybe sh')
p) (DelayedOpenAcc aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
forall sh e.
DelayedOpenAcc aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
travD DelayedOpenAcc aenv (Array sh e)
a)
    Stencil StencilR sh e stencil
s TypeR e'
tp Fun aenv (stencil -> e')
f Boundary aenv (Array sh e)
b DelayedOpenAcc aenv (Array sh e)
a                      -> UID
-> Gamma aenv
-> StencilR sh e stencil
-> TypeR e'
-> IRFun1 arch aenv (stencil -> e')
-> IRBoundary arch aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
-> CodeGen arch (IROpenAcc arch aenv (Array sh e'))
forall arch aenv sh a stencil b.
Skeleton arch =>
UID
-> Gamma aenv
-> StencilR sh a stencil
-> TypeR b
-> IRFun1 arch aenv (stencil -> b)
-> IRBoundary arch aenv (Array sh a)
-> MIRDelayed arch aenv (Array sh a)
-> CodeGen arch (IROpenAcc arch aenv (Array sh b))
stencil1 UID
uid Gamma aenv
aenv StencilR sh e stencil
s TypeR e'
tp (Fun aenv (stencil -> e') -> IRFun1 arch aenv (stencil -> e')
forall a b. Fun aenv (a -> b) -> IRFun1 arch aenv (a -> b)
travF1 Fun aenv (stencil -> e')
f) (TypeR e
-> Boundary aenv (Array sh e) -> IRBoundary arch aenv (Array sh e)
forall e sh.
TypeR e
-> Boundary aenv (Array sh e) -> IRBoundary arch aenv (Array sh e)
travB (StencilR sh e stencil -> TypeR e
forall sh e pat. StencilR sh e pat -> TypeR e
stencilEltR StencilR sh e stencil
s) Boundary aenv (Array sh e)
b) (DelayedOpenAcc aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
forall sh e.
DelayedOpenAcc aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
travD DelayedOpenAcc aenv (Array sh e)
a)
    Stencil2 StencilR sh a1 stencil1
s1 StencilR sh b stencil2
s2 TypeR c
tp Fun aenv (stencil1 -> stencil2 -> c)
f Boundary aenv (Array sh a1)
b1 DelayedOpenAcc aenv (Array sh a1)
a1 Boundary aenv (Array sh b)
b2 DelayedOpenAcc aenv (Array sh b)
a2         -> UID
-> Gamma aenv
-> StencilR sh a1 stencil1
-> StencilR sh b stencil2
-> TypeR c
-> IRFun2 arch aenv (stencil1 -> stencil2 -> c)
-> IRBoundary arch aenv (Array sh a1)
-> MIRDelayed arch aenv (Array sh a1)
-> IRBoundary arch aenv (Array sh b)
-> MIRDelayed arch aenv (Array sh b)
-> CodeGen arch (IROpenAcc arch aenv (Array sh c))
forall arch aenv sh a stencil1 b stencil2 c.
Skeleton arch =>
UID
-> Gamma aenv
-> StencilR sh a stencil1
-> StencilR sh b stencil2
-> TypeR c
-> IRFun2 arch aenv (stencil1 -> stencil2 -> c)
-> IRBoundary arch aenv (Array sh a)
-> MIRDelayed arch aenv (Array sh a)
-> IRBoundary arch aenv (Array sh b)
-> MIRDelayed arch aenv (Array sh b)
-> CodeGen arch (IROpenAcc arch aenv (Array sh c))
stencil2 UID
uid Gamma aenv
aenv StencilR sh a1 stencil1
s1 StencilR sh b stencil2
s2 TypeR c
tp (Fun aenv (stencil1 -> stencil2 -> c)
-> IRFun2 arch aenv (stencil1 -> stencil2 -> c)
forall a b c.
Fun aenv (a -> b -> c) -> IRFun2 arch aenv (a -> b -> c)
travF2 Fun aenv (stencil1 -> stencil2 -> c)
f) (TypeR a1
-> Boundary aenv (Array sh a1)
-> IRBoundary arch aenv (Array sh a1)
forall e sh.
TypeR e
-> Boundary aenv (Array sh e) -> IRBoundary arch aenv (Array sh e)
travB (StencilR sh a1 stencil1 -> TypeR a1
forall sh e pat. StencilR sh e pat -> TypeR e
stencilEltR StencilR sh a1 stencil1
s1) Boundary aenv (Array sh a1)
b1) (DelayedOpenAcc aenv (Array sh a1)
-> MIRDelayed arch aenv (Array sh a1)
forall sh e.
DelayedOpenAcc aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
travD DelayedOpenAcc aenv (Array sh a1)
a1) (TypeR b
-> Boundary aenv (Array sh b) -> IRBoundary arch aenv (Array sh b)
forall e sh.
TypeR e
-> Boundary aenv (Array sh e) -> IRBoundary arch aenv (Array sh e)
travB (StencilR sh b stencil2 -> TypeR b
forall sh e pat. StencilR sh e pat -> TypeR e
stencilEltR StencilR sh b stencil2
s2) Boundary aenv (Array sh b)
b2) (DelayedOpenAcc aenv (Array sh b)
-> MIRDelayed arch aenv (Array sh b)
forall sh e.
DelayedOpenAcc aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
travD DelayedOpenAcc aenv (Array sh b)
a2)

    -- Non-computation forms: sadness
    Alet{}      -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
unexpectedError
    Avar{}      -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
unexpectedError
    Apply{}     -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
unexpectedError
    Acond{}     -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
unexpectedError
    Awhile{}    -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
unexpectedError
    Apair{}     -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
unexpectedError
    PreOpenAcc DelayedOpenAcc aenv arrs
Anil        -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
unexpectedError
    Use{}       -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
unexpectedError
    Unit{}      -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
unexpectedError
    Aforeign{}  -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
unexpectedError
    Reshape{}   -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
unexpectedError

    Replicate{} -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
fusionError
    Slice{}     -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
fusionError
    ZipWith{}   -> CodeGen arch (IROpenAcc arch aenv arrs)
forall error. error
fusionError

  where
    -- code generation for delayed arrays
    travD :: DelayedOpenAcc aenv (Array sh e) -> MIRDelayed arch aenv (Array sh e)
    travD :: DelayedOpenAcc aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
travD Delayed{Fun aenv (sh -> e)
Fun aenv (Int -> e)
Exp aenv sh
ArrayR (Array sh e)
linearIndexD :: forall aenv sh e.
DelayedOpenAcc aenv (Array sh e) -> Fun aenv (Int -> e)
indexD :: forall aenv sh e.
DelayedOpenAcc aenv (Array sh e) -> Fun aenv (sh -> e)
extentD :: forall aenv sh e. DelayedOpenAcc aenv (Array sh e) -> Exp aenv sh
reprD :: forall aenv sh e.
DelayedOpenAcc aenv (Array sh e) -> ArrayR (Array sh e)
linearIndexD :: Fun aenv (Int -> e)
indexD :: Fun aenv (sh -> e)
extentD :: Exp aenv sh
reprD :: ArrayR (Array sh e)
..} = IRDelayed arch aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
forall arch aenv a. IRDelayed arch aenv a -> MIRDelayed arch aenv a
IRDelayedJust (IRDelayed arch aenv (Array sh e)
 -> MIRDelayed arch aenv (Array sh e))
-> IRDelayed arch aenv (Array sh e)
-> MIRDelayed arch aenv (Array sh e)
forall a b. (a -> b) -> a -> b
$ ArrayR (Array sh e)
-> IRExp arch aenv sh
-> IRFun1 arch aenv (sh -> e)
-> IRFun1 arch aenv (Int -> e)
-> IRDelayed arch aenv (Array sh e)
forall sh e arch aenv.
ArrayR (Array sh e)
-> IRExp arch aenv sh
-> IRFun1 arch aenv (sh -> e)
-> IRFun1 arch aenv (Int -> e)
-> IRDelayed arch aenv (Array sh e)
IRDelayed ArrayR (Array sh e)
reprD (Exp aenv sh -> IRExp arch aenv sh
forall t. Exp aenv t -> IRExp arch aenv t
travE Exp aenv sh
extentD) (Fun aenv (sh -> e) -> IRFun1 arch aenv (sh -> e)
forall a b. Fun aenv (a -> b) -> IRFun1 arch aenv (a -> b)
travF1 Fun aenv (sh -> e)
indexD) (Fun aenv (Int -> e) -> IRFun1 arch aenv (Int -> e)
forall a b. Fun aenv (a -> b) -> IRFun1 arch aenv (a -> b)
travF1 Fun aenv (Int -> e)
linearIndexD)
    travD (Manifest PreOpenAcc DelayedOpenAcc aenv (Array sh e)
acc) = ArrayR (Array sh e) -> MIRDelayed arch aenv (Array sh e)
forall arch aenv a. ArrayR a -> MIRDelayed arch aenv a
IRDelayedNothing (ArrayR (Array sh e) -> MIRDelayed arch aenv (Array sh e))
-> ArrayR (Array sh e) -> MIRDelayed arch aenv (Array sh e)
forall a b. (a -> b) -> a -> b
$ PreOpenAcc DelayedOpenAcc aenv (Array sh e) -> ArrayR (Array sh e)
forall (f :: * -> * -> *) aenv sh e.
HasArraysR f =>
f aenv (Array sh e) -> ArrayR (Array sh e)
arrayR PreOpenAcc DelayedOpenAcc aenv (Array sh e)
acc

    -- scalar code generation
    travF1 :: Fun aenv (a -> b) -> IRFun1 arch aenv (a -> b)
    travF1 :: Fun aenv (a -> b) -> IRFun1 arch aenv (a -> b)
travF1 Fun aenv (a -> b)
f = Fun aenv (a -> b) -> Gamma aenv -> IRFun1 arch aenv (a -> b)
forall arch aenv a b.
(HasCallStack, Foreign arch) =>
Fun aenv (a -> b) -> Gamma aenv -> IRFun1 arch aenv (a -> b)
llvmOfFun1 Fun aenv (a -> b)
f Gamma aenv
aenv

    travF2 :: Fun aenv (a -> b -> c) -> IRFun2 arch aenv (a -> b -> c)
    travF2 :: Fun aenv (a -> b -> c) -> IRFun2 arch aenv (a -> b -> c)
travF2 Fun aenv (a -> b -> c)
f = Fun aenv (a -> b -> c)
-> Gamma aenv -> IRFun2 arch aenv (a -> b -> c)
forall arch aenv a b c.
(HasCallStack, Foreign arch) =>
Fun aenv (a -> b -> c)
-> Gamma aenv -> IRFun2 arch aenv (a -> b -> c)
llvmOfFun2 Fun aenv (a -> b -> c)
f Gamma aenv
aenv

    travPF :: Fun aenv (e -> e -> e) -> IRPermuteFun arch aenv (e -> e -> e)
    travPF :: Fun aenv (e -> e -> e) -> IRPermuteFun arch aenv (e -> e -> e)
travPF Fun aenv (e -> e -> e)
f = Fun aenv (e -> e -> e)
-> Gamma aenv -> IRPermuteFun arch aenv (e -> e -> e)
forall arch aenv e.
Foreign arch =>
Fun aenv (e -> e -> e)
-> Gamma aenv -> IRPermuteFun arch aenv (e -> e -> e)
llvmOfPermuteFun Fun aenv (e -> e -> e)
f Gamma aenv
aenv

    travE :: Exp aenv t -> IRExp arch aenv t
    travE :: Exp aenv t -> IRExp arch aenv t
travE Exp aenv t
e = Exp aenv t -> Val () -> Gamma aenv -> IRExp arch aenv t
forall arch env aenv _t.
(HasCallStack, Foreign arch) =>
OpenExp env aenv _t
-> Val env -> Gamma aenv -> IROpenExp arch env aenv _t
llvmOfOpenExp Exp aenv t
e Val ()
Empty Gamma aenv
aenv

    travB :: TypeR e
          -> Boundary aenv (Array sh e)
          -> IRBoundary arch aenv (Array sh e)
    travB :: TypeR e
-> Boundary aenv (Array sh e) -> IRBoundary arch aenv (Array sh e)
travB TypeR e
_  Boundary aenv (Array sh e)
Clamp        = IRBoundary arch aenv (Array sh e)
forall arch aenv t. IRBoundary arch aenv t
IRClamp
    travB TypeR e
_  Boundary aenv (Array sh e)
Mirror       = IRBoundary arch aenv (Array sh e)
forall arch aenv t. IRBoundary arch aenv t
IRMirror
    travB TypeR e
_  Boundary aenv (Array sh e)
Wrap         = IRBoundary arch aenv (Array sh e)
forall arch aenv t. IRBoundary arch aenv t
IRWrap
    travB TypeR e
tp (Constant e
c) = Operands e -> IRBoundary arch aenv (Array sh e)
forall e arch aenv sh.
Operands e -> IRBoundary arch aenv (Array sh e)
IRConstant (Operands e -> IRBoundary arch aenv (Array sh e))
-> Operands e -> IRBoundary arch aenv (Array sh e)
forall a b. (a -> b) -> a -> b
$ TypeR e -> e -> Operands e
forall a. TypeR a -> a -> Operands a
constant TypeR e
tp e
e
c
    travB TypeR e
_  (Function Fun aenv (sh -> e)
f) = IRFun1 arch aenv (sh -> e) -> IRBoundary arch aenv (Array sh e)
forall arch aenv sh e.
IRFun1 arch aenv (sh -> e) -> IRBoundary arch aenv (Array sh e)
IRFunction (IRFun1 arch aenv (sh -> e) -> IRBoundary arch aenv (Array sh e))
-> IRFun1 arch aenv (sh -> e) -> IRBoundary arch aenv (Array sh e)
forall a b. (a -> b) -> a -> b
$ Fun aenv (sh -> e) -> IRFun1 arch aenv (sh -> e)
forall a b. Fun aenv (a -> b) -> IRFun1 arch aenv (a -> b)
travF1 Fun aenv (sh -> e)
f

    -- sadness
    fusionError, unexpectedError :: error
    fusionError :: error
fusionError      = String -> error
forall a. HasCallStack => String -> a
internalError (String -> error) -> String -> error
forall a b. (a -> b) -> a -> b
$ String
"unexpected fusible material: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ PreOpenAcc DelayedOpenAcc aenv arrs -> String
forall (acc :: * -> * -> *) aenv arrs.
PreOpenAcc acc aenv arrs -> String
showPreAccOp PreOpenAcc DelayedOpenAcc aenv arrs
pacc
    unexpectedError :: error
unexpectedError  = String -> error
forall a. HasCallStack => String -> a
internalError (String -> error) -> String -> error
forall a b. (a -> b) -> a -> b
$ String
"unexpected array primitive: "  String -> String -> String
forall a. [a] -> [a] -> [a]
++ PreOpenAcc DelayedOpenAcc aenv arrs -> String
forall (acc :: * -> * -> *) aenv arrs.
PreOpenAcc acc aenv arrs -> String
showPreAccOp PreOpenAcc DelayedOpenAcc aenv arrs
pacc