-- * Flags and settings

         DynFlags(..), GeneralFlag(..), Severity(..), Backend, gopt,

         GhcMode(..), GhcLink(..),

         parseDynamicFlags, parseTargetFiles,

         getSessionDynFlags,

    , llvmBackend

    , jsBackend

    , viaCBackend

    , noBackend

    , allBackends

   show = backendDescription

     :: Backend

 -- | The native code generator.

 -- (foreign primops).

 --

 -- See "GHC.StgToByteCode"

 -- | A dummy back end that generates no code.

 --

 backendDescription (Named LLVM)        = "LLVM"

 backendDescription (Named ViaC)        = "compiling via C"

 backendDescription (Named JavaScript)  = "compiling to JavaScript"

 backendDescription (Named NoBackend)   = "no code generated"

 -- | This flag tells the compiler driver whether the back

 backendWritesFiles (Named LLVM)        = True

 backendWritesFiles (Named ViaC)        = True

 backendWritesFiles (Named JavaScript)  = True

 backendWritesFiles (Named NoBackend)   = False

 -- | When the back end does write files, this value tells

 backendPipelineOutput (Named LLVM) = Persistent

 backendPipelineOutput (Named ViaC) = Persistent

 backendPipelineOutput (Named JavaScript)  = Persistent

 backendPipelineOutput (Named NoBackend)   = NoOutputFile

 -- | This flag tells the driver whether the back end can

 backendCanReuseLoadedCode (Named LLVM)        = False

 backendCanReuseLoadedCode (Named ViaC)        = False

 backendCanReuseLoadedCode (Named JavaScript)  = False

 backendCanReuseLoadedCode (Named NoBackend)   = False

 -- | It is is true of every back end except @-fno-code@

 backendGeneratesCode (Named LLVM)        = True

 backendGeneratesCode (Named ViaC)        = True

 backendGeneratesCode (Named JavaScript)  = True

 backendGeneratesCode (Named NoBackend)   = False

 backendGeneratesCodeForHsBoot :: Backend -> Bool

 backendGeneratesCodeForHsBoot (Named LLVM)        = True

 backendGeneratesCodeForHsBoot (Named ViaC)        = True

 backendGeneratesCodeForHsBoot (Named JavaScript)  = True

 backendGeneratesCodeForHsBoot (Named NoBackend)   = False

 -- | When set, this flag turns on interface writing for

 backendSupportsInterfaceWriting (Named LLVM)        = True

 backendSupportsInterfaceWriting (Named ViaC)        = True

 backendSupportsInterfaceWriting (Named JavaScript)  = True

 backendSupportsInterfaceWriting (Named NoBackend)   = False

 -- | When preparing code for this back end, the type

 backendRespectsSpecialise (Named LLVM)        = True

 backendRespectsSpecialise (Named ViaC)        = True

 backendRespectsSpecialise (Named JavaScript)  = True

 backendRespectsSpecialise (Named NoBackend)   = False

 -- | This back end wants the `mi_top_env` field of a

 backendWantsGlobalBindings (Named ViaC)        = False

 backendWantsGlobalBindings (Named JavaScript)  = False

 backendWantsGlobalBindings (Named NoBackend)   = False

 -- | The back end targets a technology that implements

 -- `switch` natively.  (For example, LLVM or C.) Therefore

 backendHasNativeSwitch (Named LLVM)        = True

 backendHasNativeSwitch (Named ViaC)        = True

 backendHasNativeSwitch (Named JavaScript)  = True

 backendHasNativeSwitch (Named NoBackend)   = False

 -- | As noted in the documentation for

 backendPrimitiveImplementation (Named LLVM)        = LlvmPrimitives

 backendPrimitiveImplementation (Named JavaScript)  = JSPrimitives

 backendPrimitiveImplementation (Named ViaC)        = GenericPrimitives

 backendPrimitiveImplementation (Named NoBackend)   = GenericPrimitives

 -- | When this value is `IsValid`, the back end is

 backendSimdValidity (Named LLVM)        = IsValid

 backendSimdValidity (Named ViaC)        = NotValid $ unlines ["SIMD vector instructions require using the NCG or the LLVM backend."]

 backendSimdValidity (Named JavaScript)  = NotValid $ unlines ["SIMD vector instructions require using the NCG or the LLVM backend."]

 backendSimdValidity (Named NoBackend)   = NotValid $ unlines ["SIMD vector instructions require using the NCG or the LLVM backend."]

 -- | This flag says whether the back end supports large

 backendSupportsEmbeddedBlobs (Named LLVM)        = False

 backendSupportsEmbeddedBlobs (Named ViaC)        = False

 backendSupportsEmbeddedBlobs (Named JavaScript)  = False

 backendSupportsEmbeddedBlobs (Named NoBackend)   = False

 -- | This flag tells the compiler driver that the back end

 backendNeedsPlatformNcgSupport (Named LLVM)        = False

 backendNeedsPlatformNcgSupport (Named ViaC)        = False

 backendNeedsPlatformNcgSupport (Named JavaScript)  = False

 backendNeedsPlatformNcgSupport (Named NoBackend)   = False

 -- | This flag is set if the back end can generate code

 backendSupportsUnsplitProcPoints (Named LLVM)        = False

 backendSupportsUnsplitProcPoints (Named ViaC)        = False

 backendSupportsUnsplitProcPoints (Named JavaScript)  = False

 backendSupportsUnsplitProcPoints (Named NoBackend)   = False

 -- | This flag guides the driver in resolving issues about

 backendSwappableWithViaC (Named LLVM)        = True

 backendSwappableWithViaC (Named ViaC)        = False

 backendSwappableWithViaC (Named JavaScript)  = False

 backendSwappableWithViaC (Named NoBackend)   = False

 -- | This flag is true if the back end works *only* with

 backendUnregisterisedAbiOnly (Named LLVM)        = False

 backendUnregisterisedAbiOnly (Named ViaC)        = True

 backendUnregisterisedAbiOnly (Named JavaScript)  = False

 backendUnregisterisedAbiOnly (Named NoBackend)   = False

 -- | This flag is set if the back end generates C code in

 backendGeneratesHc (Named LLVM)        = False

 backendGeneratesHc (Named ViaC)        = True

 backendGeneratesHc (Named JavaScript)  = False

 backendGeneratesHc (Named NoBackend)   = False

 -- | This flag says whether SPT (static pointer table)

 backendSptIsDynamic (Named LLVM)        = False

 backendSptIsDynamic (Named ViaC)        = False

 backendSptIsDynamic (Named JavaScript)  = False

 backendSptIsDynamic (Named NoBackend)   = False

 -- | If this flag is unset, then the driver ignores the flag @-fbreak-points@,

   Named LLVM        -> False

   Named ViaC        -> False

   Named JavaScript  -> False

   Named NoBackend   -> False

 -- | If this flag is set, then the driver forces the

 backendForcesOptimization0 (Named LLVM)        = False

 backendForcesOptimization0 (Named ViaC)        = False

 backendForcesOptimization0 (Named JavaScript)  = False

 backendForcesOptimization0 (Named NoBackend)   = False

 -- | I don't understand exactly how this works.  But if

 backendNeedsFullWays (Named LLVM)        = False

 backendNeedsFullWays (Named ViaC)        = False

 backendNeedsFullWays (Named JavaScript)  = False

 backendNeedsFullWays (Named NoBackend)   = False

 -- | This flag is also special for the interpreter: if a

 backendSpecialModuleSource (Named LLVM)        = const Nothing

 backendSpecialModuleSource (Named ViaC)        = const Nothing

 backendSpecialModuleSource (Named JavaScript)  = const Nothing

 backendSpecialModuleSource (Named NoBackend)   = const (Just "nothing")

 -- | This flag says whether the back end supports Haskell

 backendSupportsHpc (Named LLVM)        = True

 backendSupportsHpc (Named ViaC)        = True

 backendSupportsHpc (Named JavaScript)  = False

 backendSupportsHpc (Named NoBackend)   = True

 -- | This flag says whether the back end supports foreign

 backendSupportsCImport (Named LLVM)        = True

 backendSupportsCImport (Named ViaC)        = True

 backendSupportsCImport (Named JavaScript)  = True

 backendSupportsCImport (Named NoBackend)   = True

 -- | This flag says whether the back end supports foreign

 backendSupportsCExport (Named LLVM)        = True

 backendSupportsCExport (Named ViaC)        = True

 backendSupportsCExport (Named JavaScript)  = True

 backendSupportsCExport (Named NoBackend)   = True

 -- | When using this back end, it may be necessary or

 backendCDefs (Named LLVM)        = LlvmCDefs

 backendCDefs (Named ViaC)        = NoCDefs

 backendCDefs (Named JavaScript)  = NoCDefs

 backendCDefs (Named NoBackend)   = NoCDefs

 -- | This (defunctionalized) function generates code and

 backendCodeOutput (Named LLVM)        = LlvmCodeOutput

 backendCodeOutput (Named ViaC)        = ViaCCodeOutput

 backendCodeOutput (Named JavaScript)  = JSCodeOutput

 backendCodeOutput (Named NoBackend)   = panic "backendCodeOutput: noBackend"

 backendUseJSLinker :: Backend -> Bool

 backendUseJSLinker (Named LLVM)        = False

 backendUseJSLinker (Named ViaC)        = False

 backendUseJSLinker (Named JavaScript)  = True

 backendUseJSLinker (Named NoBackend)   = False

 -- | This (defunctionalized) function tells the compiler

 backendPostHscPipeline (Named LLVM) = LlvmPostHscPipeline

 backendPostHscPipeline (Named ViaC) = ViaCPostHscPipeline

 backendPostHscPipeline (Named JavaScript)  = JSPostHscPipeline

 backendPostHscPipeline (Named NoBackend) = NoPostHscPipeline

 -- | Somewhere in the compiler driver, when compiling

 backendNormalSuccessorPhase (Named LLVM) = LlvmOpt

 backendNormalSuccessorPhase (Named ViaC) = HCc

 backendNormalSuccessorPhase (Named JavaScript)  = StopLn

 backendNormalSuccessorPhase (Named NoBackend)   = StopLn

 -- | Name of the back end, if any.  Used to migrate legacy

 backendName (Named LLVM) = LLVM

 backendName (Named ViaC) = ViaC

 backendName (Named JavaScript)  = JavaScript

 backendName (Named NoBackend)   = NoBackend

               , llvmBackend

               , viaCBackend

               , jsBackend

               , noBackend

               ]

    | LLVM          -- ^ Names the LLVM backend.

    | ViaC          -- ^ Names the Via-C backend.

    | JavaScript    -- ^ Names the JS backend.

    | NoBackend     -- ^ Names the `-fno-code` backend.

  deriving (Eq, Show)

                    else (,) <$> (new_temp_file (hiSuf_ dflags) (dynHiSuf_ dflags))

                             <*> (new_temp_file (objectSuf_ dflags) (dynObjectSuf_ dflags))

                let new_dflags = case enable_spec of

                                   EnableObject   -> dflags { backend = defaultBackendOf ms }

                                   EnableByteCodeAndObject -> (gopt_set dflags Opt_ByteCodeAndObjectCode) { backend = defaultBackendOf ms}

                let ms' = ms

     , showModuleIndex

     , hscAddSptEntries

     , writeInterfaceOnlyMode

     , genModDetails

     ) where

               return $ HscRecompNeeded $ Just $ mi_iface_hash $ checked_iface

            | otherwise -> do

                obj_linkable <- liftIO $ checkObjects lcl_dflags (homeMod_object old_linkable) mod_summary

                                (UpToDateItem bc, UpToDateItem o) -> UpToDateItem (bytecodeAndObjects bc o)

                                -- If missing object code, just say we need to recompile because of object code.

                                (_, OutOfDateItem reason _) -> OutOfDateItem reason Nothing

                                -- end up using bytecode on recompilation

                                (OutOfDateItem reason _,  _ ) -> OutOfDateItem reason Nothing

 --               pprTraceM "recomp" (ppr just_bc <+> ppr just_o)

                -- 2. Decide which of the products we will need

                let recomp_linkable_result = case () of

                      _ | backendCanReuseLoadedCode (backend lcl_dflags) ->

                         -- Need object files for making object files

                         | backendWritesFiles (backend lcl_dflags) ->

                            if gopt Opt_ByteCodeAndObjectCode lcl_dflags

                    msg $ NeedsRecompile reason

                    return $ HscRecompNeeded $ Just $ mi_iface_hash $ checked_iface

 -- | Check that the .o files produced by compilation are already up-to-date

 -- or not.

 checkObjects :: DynFlags -> Maybe Linkable -> ModSummary -> IO (MaybeValidated Linkable)

 -- | Check to see if we can reuse the old linkable, by this point we will

 -- have just checked that the old interface matches up with the source hash, so

 -- no need to check that again here

   case mb_old_linkable of

     Just old_linkable

       | not (linkableIsNativeCodeOnly old_linkable)

       -> return $ (UpToDateItem old_linkable)

 -- | Load bytecode from a ".gbc" object file if it exists and is up-to-date

   let

     obj_fn = ml_bytecode_file (ms_location mod_sum)

     obj_date = ms_bytecode_date mod_sum

   case (,) <$> obj_date <*> if_date of

     Just (obj_date, if_date)

       | obj_date >= if_date -> do

 -- | Attempt to load bytecode from whole core bindings in the interface if they exist.

 -- This is a legacy code-path, these days it should be preferred to use the bytecode object linkable.

     let

       this_mod   = ms_mod mod_sum

       if_date    = fromJust $ ms_iface_date mod_sum

         ~(bco, fos) <- unsafeInterleaveIO $

                        compileWholeCoreBindings hsc_env (md_types mod_details) fi

         let bco' = LazyBCOs bco fos

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

 -- Compilers

 generateAndWriteByteCodeLinkable :: HscEnv -> CgInteractiveGuts -> ModLocation -> IO Linkable

 generateAndWriteByteCodeLinkable hsc_env cgguts mod_location = do

   bco_object <- generateAndWriteByteCode hsc_env cgguts mod_location

   loadByteCodeObjectLinkable hsc_env bco_time mod_location bco_object

 -- | Write foreign sources and foreign stubs to temporary files and compile them.

          -- was set), force it to generate byte-code. This is NOT transitive and

          -- only applies to direct targets.

          | loadAsByteCode

            )

          | otherwise

   , make_ord_flag defFlag "fno-code"         (NoArg ((upd $ \d ->

                   d { ghcLink=NoLink }) >> setBackend noBackend))

   , make_ord_flag defFlag "fbyte-code"

   , make_ord_flag defFlag "fobject-code"     $ noArgM $ \dflags -> do

       setBackend $ platformDefaultBackend (targetPlatform dflags)

       dflags' <- liftEwM getCmdLineState

 -- If we're linking a binary, then only backends that produce object

 -- code are allowed (requests for other target types are ignored).

 setBackend :: Backend -> DynP ()

 -- Changes the target only if we're compiling object code.  This is

 -- used by -fasm and -fllvm, which switch from one to the other, but

         setGeneralFlag' Opt_ExternalInterpreter $

         addWay' WayDyn dflags

  | LinkInMemory <- ghcLink dflags

  , not (gopt Opt_ExternalInterpreter dflags)

  , targetWays_ dflags /= hostFullWays

     then any modules which are required to be compiled for Template Haskell evaluation

     will generate byte-code rather than object code.

 .. _options-linker:

     Finally, the option ``-hcsuf`` ⟨suffix⟩ will change the ``.hc`` file

     suffix for compiler-generated intermediate C files.

 .. _keeping-intermediates:

 Keeping Intermediate Files

   let dflt_backend = backend dflags0

       (mode, bcknd, link)

          = case postLoadMode of

                DoMake          -> (CompManager, dflt_backend, LinkBinary)

                DoBackpack      -> (CompManager, dflt_backend, LinkBinary)

                DoMkDependHS    -> (MkDepend,    dflt_backend, LinkBinary)