-- | C code generator.  This module can convert a correct ImpCode
-- program to an equivalent C program.  This C program is expected to
-- be converted to WebAssembly, so we also produce the intended
-- JavaScript wrapper.
module Futhark.CodeGen.Backends.MulticoreWASM
  ( compileProg,
    runServer,
    libraryExports,
    GC.CParts (..),
    GC.asLibrary,
    GC.asExecutable,
    GC.asServer,
  )
where

import Data.Maybe
import Data.Text qualified as T
import Futhark.CodeGen.Backends.GenericC qualified as GC
import Futhark.CodeGen.Backends.GenericWASM
import Futhark.CodeGen.Backends.MulticoreC qualified as MC
import Futhark.CodeGen.Backends.MulticoreC.Boilerplate (generateBoilerplate)
import Futhark.CodeGen.ImpCode.Multicore qualified as Imp
import Futhark.CodeGen.ImpGen.Multicore qualified as ImpGen
import Futhark.IR.MCMem
import Futhark.MonadFreshNames

-- | Compile Futhark program to wasm-multicore program (some assembly
-- required).
--
-- The triple that is returned consists of
--
-- * Generated C code (to be passed to Emscripten).
--
-- * JavaScript wrapper code that presents a nicer interface to the
--   Emscripten-produced code (this should be put in a @.class.js@
--   file by itself).
--
-- * Options that should be passed to @emcc@.
compileProg ::
  (MonadFreshNames m) =>
  T.Text ->
  Prog MCMem ->
  m (ImpGen.Warnings, (GC.CParts, T.Text, [String]))
compileProg :: forall (m :: * -> *).
MonadFreshNames m =>
Text -> Prog MCMem -> m (Warnings, (CParts, Text, [String]))
compileProg Text
version Prog MCMem
prog = do
  (ws, prog') <- Prog MCMem -> m (Warnings, Definitions Multicore)
forall (m :: * -> *).
MonadFreshNames m =>
Prog MCMem -> m (Warnings, Definitions Multicore)
ImpGen.compileProg Prog MCMem
prog

  prog'' <-
    GC.compileProg
      "wasm_multicore"
      version
      mempty
      MC.operations
      generateBoilerplate
      ""
      (DefaultSpace, [DefaultSpace])
      MC.cliOptions
      prog'

  pure
    ( ws,
      ( prog'',
        javascriptWrapper (fRepMyRep prog'),
        "_futhark_context_config_set_num_threads" : emccExportNames (fRepMyRep prog')
      )
    )

fRepMyRep :: Imp.Definitions Imp.Multicore -> [JSEntryPoint]
fRepMyRep :: Definitions Multicore -> [JSEntryPoint]
fRepMyRep Definitions Multicore
prog =
  let Imp.Functions [(Name, Function Multicore)]
fs = Definitions Multicore -> Functions Multicore
forall a. Definitions a -> Functions a
Imp.defFuns Definitions Multicore
prog
      function :: FunctionT a -> Maybe JSEntryPoint
function (Imp.Function Maybe EntryPoint
entry [Param]
_ [Param]
_ Code a
_) = do
        Imp.EntryPoint n res args <- Maybe EntryPoint
entry
        Just $
          JSEntryPoint
            { name = nameToString n,
              parameters = map (extToString . snd) args,
              ret = map (extToString . snd) res
            }
   in ((Name, Function Multicore) -> Maybe JSEntryPoint)
-> [(Name, Function Multicore)] -> [JSEntryPoint]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (Function Multicore -> Maybe JSEntryPoint
forall {a}. FunctionT a -> Maybe JSEntryPoint
function (Function Multicore -> Maybe JSEntryPoint)
-> ((Name, Function Multicore) -> Function Multicore)
-> (Name, Function Multicore)
-> Maybe JSEntryPoint
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Name, Function Multicore) -> Function Multicore
forall a b. (a, b) -> b
snd) [(Name, Function Multicore)]
fs