import GHC.Utils.Error

 import GHC.Driver.Pipeline.Monad

 import GHC.Platform

 -- We expect one function per back end—or more precisely, one function

 -- for each back end that writes code to a file.  (The interpreter

 -- does not write to files; its output lives only in memory.)

 data DefunctionalizedCodeOutput

   = NcgCodeOutput

   | ViaCCodeOutput

 -- > -> Set UnitId -- ^ dependencies

 -- > -> Stream IO RawCmmGroup a -- results from `StgToCmm`

 -- > -> IO a

 backendUseJSLinker :: Backend -> Bool

 backendUseJSLinker (Named NCG)         = False

 backendUseJSLinker (Named LLVM)        = False

 backendUseJSLinker (Named ViaC)        = False

 backendUseJSLinker (Named JavaScript)  = True

 backendUseJSLinker (Named NoBackend)   = False

 -- | This (defunctionalized) function tells the compiler

 \section{Code output phase}

 -}

 module GHC.Driver.CodeOutput

    ( codeOutput

    , outputForeignStubs

 import GHC.Utils.Logger

 import GHC.Utils.Exception ( bracket )

 import GHC.Utils.Ppr (Mode(..))

 import GHC.Unit

 import GHC.Unit.Finder      ( mkStubPaths )

 import System.IO

 import Data.Set (Set)

 import qualified Data.Set as Set

 {-

 ************************************************************************

         ; let dus1 = newTagDUniqSupply CodeGenTag dus0

         ; (stubs, a) <- case backendCodeOutput (backend dflags) of

         ; stubs_exist <- outputForeignStubs logger tmpfs dflags unit_state this_mod location stubs

         ; return (filenm, stubs_exist, foreign_fps, a)

         }

 {-# LANGUAGE MultiWayIf #-}

 {-# OPTIONS_GHC -fprof-auto-top #-}

 -------------------------------------------------------------------------------

 --

         -- next withTiming after this will be "Assembler" (hard code only).

         withTiming logger (text "CodeGen"<+>brackets (ppr this_mod)) (const ())

          $ case backendCodeOutput (backend dflags) of

               do

               let js_config = initStgToJSConfig dflags

               stgToJS logger js_config stg_binds this_mod spt_entries foreign_stubs0 cost_centre_info output_filename

               return (output_filename, stub_c_exists, foreign_fps, Just stg_cg_infos, Just cmm_cg_infos)

               do

               cmms <- {-# SCC "StgToCmm" #-}

                 doCodeGen hsc_env this_mod denv tycons

                     foreign_stubs foreign_files dependencies (initDUniqSupply 'n' 0) rawcmms1

               return  ( output_filename, stub_c_exists, foreign_fps

                       , Just stg_cg_infos, Just cmm_cg_infos)

 -- The part of CgGuts that we need for HscInteractive

   let home_unit = hsc_home_unit hsc_env

   case backendCodeOutput (backend dflags) of

       empty_stub <- newTempName logger tmpfs (tmpDir dflags) TFL_CurrentModule "js"

       let src = ppr (mkHomeModule home_unit mod_name) <+> text "= 0;"

       writeFile empty_stub (showSDoc dflags (pprCode src))

       _ <- runPipeline (hsc_hooks hsc_env) pipeline

       pure ()

       empty_stub <- newTempName logger tmpfs (tmpDir dflags) TFL_CurrentModule "c"

       let src = text "int" <+> ppr (mkHomeModule home_unit mod_name) <+> text "= 0;"

       writeFile empty_stub (showSDoc dflags (pprCode src))

           pipeline = viaCPipeline HCc pipe_env hsc_env (Just location) empty_stub

       _ <- runPipeline (hsc_hooks hsc_env) pipeline

       pure ()

    && os == OSMinGW32

    && arch == ArchAArch64

     = case backendCodeOutput (backend dflags) of

         _ -> (dflags, mempty, mempty)

   -- When we do ghci, force using dyn ways if the target RTS linker