import System.Directory ( getCurrentDirectory )

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

               -> CgStream RawCmmGroup a

               -> UniqDSMT IO a

 nativeCodeGen logger ts config modLoc h cmms

 import qualified GHC.CmmToAsm.AArch64.CodeGen as AArch64

 import qualified GHC.CmmToAsm.AArch64.Regs    as AArch64

 import qualified GHC.CmmToAsm.AArch64.RegInfo as AArch64

 ncgAArch64 config

  = NcgImpl {

         ncgConfig                 = config

 --   data GenBasicBlock i = BasicBlock BlockId [i]

 cmmTopCodeGen

     -> NatM [NatCmmDecl RawCmmStatics Instr]

 -- Thus we'll have to deal with either CmmProc ...

   return [CmmData sec dat] -- no translation, we just use CmmStatic

 basicBlockCodeGen

         -> NatM ( [NatBasicBlock Instr]

                 , [NatCmmDecl RawCmmStatics Instr])

 ncgX86 = ncgX86_64

 ncgX86_64 config = NcgImpl

    { ncgConfig                 = config

    , cmmTopCodeGen             = X86.cmmTopCodeGen

 avx512dqEnabled = ncgAvx512dqEnabled <$> getConfig

 cmmTopCodeGen

         -> NatM [NatCmmDecl (Alignment, RawCmmStatics) Instr]

 cmmTopCodeGen (CmmProc info lab live graph) = do

                    (pprInstr platform i <+> text "in:" $$ vcat (map (pprInstr platform) instrs))

 basicBlockCodeGen

         -> NatM ( [NatBasicBlock Instr]

                 , [NatCmmDecl (Alignment, RawCmmStatics) Instr])

 -- See Note [Keeping track of the current block] for why

 -- we pass the BlockId.

               -> [CmmNode O O] -- ^ Cmm Statement

               -> NatM (InstrBlock, BlockId) -- ^ Resulting instruction

 stmtsToInstrs bid stmts =

 -- | `bid` refers to the current block and is used to update the CFG

 --   if new blocks are inserted in the control flow.

 -- See Note [Keeping track of the current block] for more details.

              -> CmmNode e x

              -> NatM (InstrBlock, Maybe BlockId)

              -- ^ Instructions, and bid of new block if successive

 assignReg_I64Code _ _

    = panic "assignReg_I64Code(i386): invalid lvalue"

 iselExpr64 (CmmLit (CmmInt i _)) = do

   Reg64 rhi rlo <- getNewReg64

   let

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

 getRegister e = do platform <- getPlatform

                    is32Bit <- is32BitPlatform

                    getRegister' platform is32Bit e

 getRegister' platform is32Bit (CmmReg reg)

   = case reg of

 -- Compute an expression into *any* register, adding the appropriate

 -- move instruction if necessary.

 getAnyReg expr = do

   r <- getRegister expr

   anyReg r

 anyReg (Any _ code)          = return code

 anyReg (Fixed rep reg fcode) = do

   config <- getConfig

 -- A bit like getSomeReg, but we want a reg that can be byte-addressed.

 -- Fixed registers might not be byte-addressable, so we make sure we've

 -- got a temporary, inserting an extra reg copy if necessary.

 getByteReg expr = do

   config <- getConfig

   is32Bit <- is32BitPlatform

 -- Another variant: this time we want the result in a register that cannot

 -- be modified by code to evaluate an arbitrary expression.

 getNonClobberedReg expr = do

   r <- getRegister expr

   config <- getConfig

 -- to take/return a block id.

 genForeignCall

     -> [CmmFormal]   -- ^ where to put the result

     -> [CmmActual]   -- ^ arguments (of mixed type)

     -> BlockId       -- ^ The block we are in

 -- | Generate C call to the given function in ghc-prim

 genPrimCCall

   -> FastString

   -> [CmmFormal]

   -> [CmmActual]

 -- | Generate C call to the given function in libc

 genLibCCall

   -> FastString

   -> [CmmFormal]

   -> [CmmActual]

 -- | Generate C call to the given function in the RTS

 genRTSCCall

   -> FastString

   -> [CmmFormal]

   -> [CmmActual]

 -- | Generate a real C call to the given address with the given convention

 genCCall

   -> CmmExpr

   -> ForeignConvention

   -> [CmmFormal]

                 call `appOL`

                 assign_code dest_regs)

            -> ForeignConvention -- ^ calling convention

            -> [CmmFormal]       -- ^ where to put the result

            -> [CmmActual]       -- ^ arguments (of mixed type)

 import System.IO

 import Data.Set (Set)

 import qualified Data.Set as Set

 {-

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

 codeOutput

     :: forall a.

     -> TmpFs

     -> LlvmConfigCache

     -> DynFlags

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

 -}

           -> DynFlags

           -> Module

           -> ModLocation

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

 -- | Compile to hard-code.

                -> IO (FilePath, Maybe FilePath, [(ForeignSrcLang, FilePath)], Maybe StgCgInfos, Maybe CmmCgInfos )

                 -- ^ @Just f@ <=> _stub.c is f

 hscGenHardCode hsc_env cgguts mod_loc output_filename = do

   return $ mkModuleByteCodeLinkable bco_time bco_object

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

 hscCompileCmmFile hsc_env original_filename filename output_filename = runHsc hsc_env $ do

     let dflags   = hsc_dflags hsc_env

         logger   = hsc_logger hsc_env

       . s . showString "\n\n"

       . showString "Please report this as a GHC bug:  https://www.haskell.org/ghc/reportabug\n"

 throwPlainGhcException = Exception.throw

 -- | Panics and asserts.

 panic, sorry, pgmError :: HasCallStack => String -> a

 sorry    x = throwPlainGhcException (PlainSorry x)

 pgmError x = throwPlainGhcException (PlainProgramError x)