*)

       read -r -a args <<< "${INSTALL_CONFIGURE_ARGS:-}"

       run ${CONFIGURE_WRAPPER:-} ./configure \

           --prefix="$instdir" \

           "${args[@]+"${args[@]}"}" || fail "bindist configure failed"

           -- unexpected triple.

         . setVariable "CFLAGS" cflags

         . setVariable "CONF_CC_OPTS_STAGE2" cflags

         ) where

             llvm_prefix = "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-"

             cflags = "-fuse-ld=" ++ llvm_prefix ++ "ld --rtlib=compiler-rt"

       "STRINGS": "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-strings",

       "STRIP": "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-strip",

       "TEST_ENV": "aarch64-linux-deb12-wine-int_native-cross_aarch64-unknown-mingw32-validate",

       "WindresCmd": "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-windres"

     }

   },

       "STRINGS": "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-strings",

       "STRIP": "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-strip",

       "TEST_ENV": "aarch64-linux-deb12-wine-int_native-cross_aarch64-unknown-mingw32-validate+llvm",

       "WindresCmd": "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-windres"

     }

   },

       "STRINGS": "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-strings",

       "STRIP": "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-strip",

       "TEST_ENV": "aarch64-linux-deb12-wine-int_native-cross_aarch64-unknown-mingw32-validate",

       "WindresCmd": "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-windres",

       "XZ_OPT": "-9"

     }

       "STRINGS": "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-strings",

       "STRIP": "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-strip",

       "TEST_ENV": "aarch64-linux-deb12-wine-int_native-cross_aarch64-unknown-mingw32-validate+llvm",

       "WindresCmd": "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-windres",

       "XZ_OPT": "-9"

     }

 import GHC.Types.SrcLoc

 import GHC.Types.Name.Occurrence

 import Control.DeepSeq

 import Data.IntMap.Strict (IntMap)

 import qualified Data.IntMap.Strict as IM

 getBreakDecls :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO [String]

 getBreakDecls = getBreakXXX modBreaks_decls

 getBreakCCS = getBreakXXX modBreaks_ccs

 -- | Internal utility to access a ModBreaks field at a particular breakpoint index

         symbol

           | null unit = ztmp

           | otherwise = zEncodeString unit ++ "_" ++ ztmp

       Nothing -> pprPanic "loadExternalPlugins"

                   (vcat [ text "Symbol not found"

                         , text "  Library path: " <> text path

 import GHC.Prelude

 import Data.Array

 import GHC.HsToCore.Ticks (Tick (..))

 import GHC.Data.SizedSeq

 import GHC.Types.Tickish (BreakTickIndex, BreakpointId(..))

 import GHC.Unit.Module (Module)

 import GHC.Utils.Binary

 import GHC.Utils.Outputable

 import Data.List (intersperse)

 import Data.Coerce

    , modBreaks_decls  :: !(Array BreakTickIndex [String])

         -- ^ An array giving the names of the declarations enclosing each breakpoint.

         -- See Note [Field modBreaks_decls]

         -- ^ Array pointing to cost centre info for each breakpoint;

         -- actual 'CostCentre' allocation is done at link-time.

    , modBreaks_module :: !Module

           | interpreterProfiled =

               listArray

                 (0, count - 1)

                   )

                 | t <- entries

                 ]

             ccs <- {- one ccs ptr per tick index -}

               mkCostCentres

                 interp

                 (elems modBreaks_ccs)

             return $ M.fromList $

               zipWith (\el ix -> (BreakpointId modBreaks_module ix, el)) ccs [0..]

 import Control.Monad.Catch as MC (mask)

 import Data.Binary

 import Data.ByteString (ByteString)

 import Foreign hiding (void)

 import qualified GHC.Exts.Heap as Heap

 import GHC.Stack.CCS (CostCentre,CostCentreStack)

 mallocData :: Interp -> ByteString -> IO (RemotePtr ())

 mallocData interp bs = interpCmd interp (MallocData bs)

 -- | Create a set of BCOs that may be mutually recursive.

 createBCOs :: Interp -> [ResolvedBCO] -> IO [HValueRef]

 evalBreakpointToId eval_break =

   let

     mkUnitId u = fsToUnit $ mkFastStringShortByteString u

   in

     InternalBreakpointId

       { ibi_info_mod   = toModule (eb_info_mod_unit eval_break) (eb_info_mod eval_break)

 lookupSymbol interp str = withSymbolCache interp str $

   case interpInstance interp of

 #if defined(HAVE_INTERNAL_INTERPRETER)

 #endif

     ExternalInterp ext -> case ext of

       ExtIServ i -> withIServ i $ \inst -> fmap fromRemotePtr <$> do

         uninterruptibleMask_ $

       ExtJS {} -> pprPanic "lookupSymbol not supported by the JS interpreter" (ppr str)

       ExtWasm i -> withWasmInterp i $ \inst -> fmap fromRemotePtr <$> do

         uninterruptibleMask_ $

 lookupSymbolInDLL :: Interp -> RemotePtr LoadedDLL -> InterpSymbol s -> IO (Maybe (Ptr ()))

 lookupSymbolInDLL interp dll str = withSymbolCache interp str $

   case interpInstance interp of

 #if defined(HAVE_INTERNAL_INTERPRETER)

 #endif

     ExternalInterp ext -> case ext of

       ExtIServ i -> withIServ i $ \inst -> fmap fromRemotePtr <$> do

         uninterruptibleMask_ $

       ExtJS {} -> pprPanic "lookupSymbol not supported by the JS interpreter" (ppr str)

       -- wasm dyld doesn't track which symbol comes from which .so

       ExtWasm {} -> lookupSymbol interp str

 lookupClosure :: Interp -> InterpSymbol s -> IO (Maybe HValueRef)

 lookupClosure interp str =

 -- | 'withSymbolCache' tries to find a symbol in the 'interpLookupSymbolCache'

 -- which maps symbols to the address where they are loaded.

 import Control.Monad            ( when, (<$!>), unless, forM_, void )

 import Foreign hiding (bit, setBit, clearBit, shiftL, shiftR, void)

 import Data.Array

 import Data.Array.IO

 import Data.Array.Unsafe

 import qualified Data.Binary as Binary

 instance (Ix a, Binary a, Binary b) => Binary (Array a b) where

     put_ bh arr = do

         put_ bh $ bounds arr

     get bh = do

 instance Binary a => Binary (SmallArray a) where

     put_ bh sa = do

 then

         bootstrap_host=`"${WithGhc}" --info | grep '^ ,("Host platform"' | sed -e 's/.*,"//' -e 's/")//' | tr -d '\r'`

         bootstrap_target=`"${WithGhc}" --info | grep '^ ,("Target platform"' | sed -e 's/.*,"//' -e 's/")//' | tr -d '\r'`

         if test "$bootstrap_host" != "$bootstrap_target"

         then

                 echo "Bootstrapping GHC is a cross compiler. This probably isn't going to work"

 else

   TargetPlatformFull="${target_alias}"

 fi

 AC_SUBST(CrossCompiling)

 AC_SUBST(TargetPlatformFull)

 dnl ** Which gcc to use?

 dnl --------------------------------------------------------------

 dnl * Deal with arguments telling us gmp is somewhere odd

 dnl--------------------------------------------------------------------

 dnl Various things from the source distribution configure

 bootstrap_target=@TargetPlatform@

 bootstrap_llvm_target=@LlvmTarget@

 #     And we can reconstruct the platform info using targetPlatformTriple

 # Q: What is TargetPlatformFull?

 target-platform-full  = @TargetPlatformFull@

 cross-compiling       = @CrossCompiling@

              | ProjectPatchLevel2

              | SystemGhc

              | TargetPlatformFull

              | BourneShell

              | EmsdkVersion

     ProjectPatchLevel2 -> "project-patch-level2"

     SystemGhc          -> "system-ghc"

     TargetPlatformFull -> "target-platform-full"

     BourneShell        -> "bourne-shell"

     EmsdkVersion       -> "emsdk-version"

     , interpolateVar "TablesNextToCode" $ yesNo <$> getTarget tgtTablesNextToCode

     , interpolateVar "TargetHasLibm" $ yesNo <$> getTarget tgtHasLibm

     , interpolateVar "TargetPlatform" $ getTarget targetPlatformTriple

     , interpolateVar "TargetWordBigEndian" $ getTarget isBigEndian

     , interpolateVar "TargetWordSize" $ getTarget wordSize

     , interpolateVar "Unregisterised" $ yesNo <$> getTarget tgtUnregisterised

     , interpolateVar "UseLibffiForAdjustors" $ yesNo <$> getTarget tgtUseLibffiForAdjustors

     , interpolateVar "GhcWithSMP" $ yesNo <$> targetSupportsSMP

     , interpolateVar "BaseUnitId" $ pkgUnitId Stage1 base

     ]

   where

     interp = interpretInContext (semiEmptyTarget Stage2)

           -- for upper stages. As we only use stage0 to build upper stages,

           -- this should be fine.

           ++ [ terminfo | not windowsHost, not cross ]

 -- | Packages built in 'Stage1' by default. You can change this in "UserSettings".

 stage1Packages :: Action [Package]

         , transformers

         , unlit

         , xhtml

         , if winTarget then win32 else unix

         ]

       , when (not cross)

         [ hpcBin

         , runGhc

         ]

       , when (winTarget && not cross)

         [ -- See Note [Hadrian's ghci-wrapper package]

   -- These all invoke the corresponding functions in the RTS Linker API.

   InitLinker :: Message ()

   LoadDLLs :: [String] -> Message (Either String [RemotePtr LoadedDLL])

   LoadArchive :: String -> Message () -- error?

   LoadObj :: String -> Message () -- error?

   -- | Create a set of CostCentres with the same module name

   MkCostCentres

    -> Message [RemotePtr CostCentre]

   -- | Show a 'CostCentreStack' as a @[String]@

 instance Binary a => Binary (EvalStatus_ a b)

 data EvalBreakpoint = EvalBreakpoint

   , eb_info_mod_unit :: BS.ShortByteString -- ^ Breakpoint tick module unit id

   , eb_info_index    :: Int    -- ^ Breakpoint info index

   }

 import GHCi.Message (LoadedDLL)

 import Control.Exception (throwIO, ErrorCall(..))

 import Control.Monad    ( when )

 import Data.Foldable

 import Foreign.C

 import Foreign.Marshal.Alloc ( alloca, free )

 purgeObj :: String -> IO ()

 purgeObj f = throwIO $ ErrorCall $ "purgeObj: unsupported on wasm for " <> f

   evaluate $ if r == nullPtr then Nothing else Just r

 lookupSymbolInDLL _ _ = pure Nothing

 resolveObjs :: IO Bool

 initObjLinker RetainCAFs = c_initLinker_ 1

 initObjLinker _ = c_initLinker_ 0

 lookupSymbol str_in = do

    let str = prefixUnderscore str_in

      addr <- c_lookupSymbol c_str

      if addr == nullPtr

         then return Nothing

         else return (Just addr)

 lookupSymbolInDLL dll str_in = do

    let str = prefixUnderscore str_in

      addr <- c_lookupSymbolInNativeObj dll c_str

      if addr == nullPtr

        then return Nothing

        else return (Just addr)

 prefixUnderscore

  | otherwise          = id

 -- | loadDLL loads a dynamic library using the OS's native linker

 #endif

 lookupClosure str = do

   m <- lookupSymbol str

   case m of

 import Control.Exception

 import Control.Monad

 import Data.ByteString (ByteString)

 import qualified Data.ByteString.Unsafe as B

 import GHC.Exts

 import qualified GHC.Exts.Heap as Heap

 foreign import javascript "((ptr,off) => globalThis.h$lookupClosure(h$decodeUtf8z(ptr,off)))" lookupJSClosure# :: CString -> State# RealWorld -> (# State# RealWorld, Int# #)

   case lookupJSClosure# cstr s of

     (# s', r #) -> (# s', I# r #))

 lookupJSClosure str = lookupJSClosure' str >>= \case

   0 -> pure Nothing

   r -> pure (Just (RemoteRef (RemotePtr (fromIntegral r))))

        if is_exception

        then pure Nothing

        else do

          info_mod_uid <- BS.packCString (Ptr info_mod_uid#)

          pure (Just (EvalBreakpoint info_mod info_mod_uid (I# infox#)))

      putMVar statusMVar $ EvalBreak apStack_r breakpoint resume_r ccs

   pokeElemOff (ptr :: Ptr CChar) len 0

   return (castRemotePtr (toRemotePtr ptr))

 #if defined(PROFILING)

 mkCostCentres mod ccs = do

   mapM (mk_one c_module) ccs

  where

   mk_one c_module (decl_path,srcspan) = do

     toRemotePtr <$> c_mkCostCentre c_name c_module c_srcspan

 foreign import ccall unsafe "mkCostCentre"

   c_mkCostCentre :: Ptr CChar -> Ptr CChar -> Ptr CChar -> IO (Ptr CostCentre)

 #else

 # compiler's target platform.

 AC_DEFUN([FPTOOLS_OVERRIDE_PLATFORM_FROM_BOOTSTRAP],

 [

     then

         echo "$1 platform inferred as: [$]$1"

     else

         echo "Can't work out $1 platform"

 AC_DEFUN([FIND_GHC_TOOLCHAIN_BIN],[

     case "$1" in

         YES)

             ;;

         NO)

             # We're in the source tree, so compile ghc-toolchain

 {-# LANGUAGE RecordWildCards #-}

 module Main (main) where

 import Control.Exception

 import Control.Monad

 import Foreign

 rotateSO

   :: (FunPtr (IO (StablePtr a)) -> (IO (StablePtr a)))

   -> (Maybe FilePath, FilePath)

   -> IO a

 rotateSO dynamicCall symName (old, newDLL) = do

 import GHCi.ObjLink

 lookupClosure "blah"

 module Main (main) where

 import Foreign

     }

     return 0;

   }

 }

 // The main entry point of dyld that may be run on node/browser, and