-#if defined(wasm32_HOST_ARCH)

-        let libdir = sorry "cannot spawn child process on wasm"

-#else

-#endif

-    , hscAddSptEntries

-    {- Load static pointer table entries -}

-    liftIO $ hscAddSptEntries hsc_env (cg_spt_entries tidy_cg)

-

--- | Load the given static-pointer table entries into the interpreter.

--- See Note [Grand plan for static forms] in "GHC.Iface.Tidy.StaticPtrTable".

-hscAddSptEntries :: HscEnv -> [SptEntry] -> IO ()

-hscAddSptEntries hsc_env entries = do

-    let interp = hscInterp hsc_env

-    let add_spt_entry :: SptEntry -> IO ()

-        add_spt_entry (SptEntry n fpr) = do

-            -- These are only names from the current module

-            (val, _, _) <- loadName interp hsc_env n

-            addSptEntry interp fpr val

-    mapM_ add_spt_entry entries

-

-import GHC.Linker.Types

-

-import GHC.ByteCode.Types

-

-

-  -- MP: This is a bit janky, because before you add the entries you have to extend the HPT with the module

-  -- you just compiled. Another option, would be delay adding anything until after upsweep has finished, but I

-  -- am unsure if this is sound (wrt running TH splices for example).

-  -- This function only does anything if the linkable produced is a BCO, which

-  -- used to only happen with the bytecode backend, but with

-  -- @-fprefer-byte-code@, @HomeModInfo@ has bytecode even when generating

-  -- object code, see #25230.

-  addSptEntries (hsc_env)

-                (homeModInfoByteCode hmi)

-

--- | Add the entries from a BCO linkable to the SPT table, see

--- See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.

-addSptEntries :: HscEnv -> Maybe Linkable -> IO ()

-addSptEntries hsc_env mlinkable =

-  hscAddSptEntries hsc_env

-     [ spt

-     | linkable <- maybeToList mlinkable

-     , bco <- linkableBCOs linkable

-     , spt <- bc_spt_entries bco

-     ]

-

-        -- See checkOptions, -fexternal-interpreter is

-        -- required when using --interactive with a non-standard

-        -- way (-prof, -static, or -dynamic).

-  in upsweep after we have compiled the module (see GHC.Driver.Make.upsweep').

-  , wasmInterpLibDir         ::  FilePath  -- ^ wasi-sdk sysroot libdir containing libc.so, etc

-FP_SET_CFLAGS_C99([CC],[CFLAGS],[CPPFLAGS])

-FP_SET_CFLAGS_C99([CC_STAGE0],[CONF_CC_OPTS_STAGE0],[CONF_CPP_OPTS_STAGE0])

-FP_SET_CFLAGS_C99([CC],[CONF_CC_OPTS_STAGE1],[CONF_CPP_OPTS_STAGE1])

-FP_SET_CFLAGS_C99([CC],[CONF_CC_OPTS_STAGE2],[CONF_CPP_OPTS_STAGE2])

-

-FP_SET_CFLAGS_C99([CC],[CFLAGS],[CPPFLAGS])

-dnl FP_SET_CFLAGS_C99([CC_STAGE0],[CONF_CC_OPTS_STAGE0],[CONF_CPP_OPTS_STAGE0])

-FP_SET_CFLAGS_C99([CC],[CONF_CC_OPTS_STAGE1],[CONF_CPP_OPTS_STAGE1])

-FP_SET_CFLAGS_C99([CC],[CONF_CC_OPTS_STAGE2],[CONF_CPP_OPTS_STAGE2])

-

-            -- For the ghc library, internal-interpreter only makes

-            -- sense when we're not cross compiling. For cross GHC,

-            -- external interpreter is used for loading target code

-            -- and internal interpreter is supposed to load native

-            -- code for plugins (!7377), however it's unfinished work

-            -- (#14335) and completely untested in CI for cross

-            -- backends at the moment, so we might as well disable it

-            -- for cross GHC.

-            [ andM [expr (ghcWithInterpreter stage), notCross] `cabalFlag` "internal-interpreter"

-lookupSymbolInDLL _ sym =

-  throwIO $ ErrorCall $ "lookupSymbolInDLL: unsupported on wasm for " <> sym

-AC_MSG_CHECKING([the C-- preprocessor for C99 support])

-cat > conftest.c <<EOF

-#include <stdio.h>

-#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L

-# error "Compiler does not advertise C99 conformance"

-#endif

-EOF

-if "$CMM_CPP_CMD" $CMM_CPP_ARGS conftest.c -o conftest -g0 >/dev/null 2>&1; then

-  AC_MSG_RESULT([yes])

-else

-    # Try -std=gnu99

-    if "$CMM_CPP_CMD" -std=gnu99 $CMM_CPP_ARGS conftest.c -o conftest -g0 >/dev/null 2>&1; then

-      $3="-std=gnu99 $$3"

-      AC_MSG_RESULT([needs -std=gnu99])

-    else

-      AC_MSG_ERROR([C99-compatible compiler needed])

-    fi

-fi

-rm -f conftest.c conftest.o conftest

-

-

-

-# FP_SET_CFLAGS_C99

-# ----------------------------------

-# figure out which CFLAGS are needed to place the compiler into C99 mode

-# $1 is name of CC variable (unmodified)

-# $2 is name of CC flags variable (augmented if needed)

-# $3 is name of CPP flags variable (augmented if needed)

-AC_DEFUN([FP_SET_CFLAGS_C99],

-[

-    dnl save current state of AC_PROG_CC_C99

-    FP_COPY_SHELLVAR([CC],[fp_save_CC])

-    FP_COPY_SHELLVAR([CFLAGS],[fp_save_CFLAGS])

-    FP_COPY_SHELLVAR([CPPFLAGS],[fp_save_CPPFLAGS])

-    FP_COPY_SHELLVAR([ac_cv_prog_cc_c99],[fp_save_cc_c99])

-    dnl set local state

-    CC="$$1"

-    CFLAGS="$$2"

-    CPPFLAGS="$$3"

-    unset ac_cv_prog_cc_c99

-    dnl perform detection

-    AC_PROG_CC_C99

-    fp_cc_c99="$ac_cv_prog_cc_c99"

-    case "x$ac_cv_prog_cc_c99" in

-      x)   ;; # noop

-      xno) AC_MSG_ERROR([C99-compatible compiler needed]) ;;

-      *)   $2="$$2 $ac_cv_prog_cc_c99"

-           $3="$$3 $ac_cv_prog_cc_c99"

-           ;;

-    esac

-    dnl restore saved state

-    FP_COPY_SHELLVAR([fp_save_CC],[CC])

-    FP_COPY_SHELLVAR([fp_save_CFLAGS],[CFLAGS])

-    FP_COPY_SHELLVAR([fp_save_CPPFLAGS],[CPPFLAGS])

-    FP_COPY_SHELLVAR([fp_save_cc_c99],[ac_cv_prog_cc_c99])

-    dnl cleanup

-    unset fp_save_CC

-    unset fp_save_CFLAGS

-    unset fp_save_cc_c99

-])

-  PUSH_UPD_FRAME(Sp - SIZEOF_StgUpdateFrame, R1);

-            // an EAGER_BLACKHOLE or CAF_BLACKHOLE gets turned into a

-            // BLACKHOLE here.

-            // first we turn it into a WHITEHOLE to claim it, and if

-            // successful we write our TSO and then the BLACKHOLE info pointer.

-            cur_bh_info = (const StgInfoTable *)

-                cas((StgVolatilePtr)&bh->header.info,

-                    (StgWord)bh_info,

-                    (StgWord)&stg_WHITEHOLE_info);

-

-            if (cur_bh_info != bh_info) {

-                bh_info = cur_bh_info;

-                NONATOMIC_ADD(&whitehole_threadPaused_spin, 1);

-                busy_wait_nop();

-                goto retry;

-            }

-

-            IF_NONMOVING_WRITE_BARRIER_ENABLED {

-                if (ip_THUNK(INFO_PTR_TO_STRUCT(bh_info))) {

-                    // We are about to replace a thunk with a blackhole.

-                    // Add the free variables of the closure we are about to

-                    // overwrite to the update remembered set.

-                    // N.B. We caught the WHITEHOLE case above.

-                    updateRemembSetPushThunkEager(cap,

-                                                  THUNK_INFO_PTR_TO_STRUCT(bh_info),

-                                                  (StgThunk *) bh);

-            }

-            // zero out the slop so that the sanity checker can tell

-            // where the next closure is. N.B. We mustn't do this until we have

-            // pushed the free variables to the update remembered set above.

-            OVERWRITING_CLOSURE_SIZE(bh, closure_sizeW_(bh, INFO_PTR_TO_STRUCT(bh_info)));

-            // The payload of the BLACKHOLE points to the TSO

-            RELEASE_STORE(&((StgInd *)bh)->indirectee, (StgClosure *)tso);

-            SET_INFO_RELEASE(bh,&stg_BLACKHOLE_info);

-            // .. and we need a write barrier, since we just mutated the closure:

-            recordClosureMutated(cap,bh);

-            // We pretend that bh has just been created.

-            LDV_RECORD_CREATE(bh);

-    , checkC99Support

-    cc3 <- oneOf "cc doesn't support C99" $ map checkC99Support

-        [ cc2

-        , cc2 & _ccFlags %++ "-std=gnu99"

-        ]

-    checkCcSupportsExtraViaCFlags cc3

-    return cc3

-checkC99Support :: Cc -> M Cc

-checkC99Support cc = checking "for C99 support" $ withTempDir $ \dir -> do

-    let test_o = dir </> "test.o"

-    compileC cc test_o $ unlines

-        [ "#include <stdio.h>"

-        , "#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L"

-        , "# error \"Compiler does not advertise C99 conformance\""

-        , "#endif"

-        ]

-    return cc

-

-import GHC.Toolchain.Utils (withTempDir, oneOf, expectFileExists)

-  foundCppProg <- findProgram "Cmm preprocessor" progOpt [] <|> pure (programFromOpt progOpt (prgPath $ ccProgram cc) [])

-  -- Check whether the C preprocessor needs -std=gnu99 (only very old toolchains need this)

-  Cc cpp <- oneOf "cc doesn't support C99" $ map checkC99Support

-        [ Cc foundCppProg

-        , Cc (foundCppProg & _prgFlags %++ "-std=gnu99")

-        ]

-

-  foundCppProg <- findProgram "C preprocessor" progOpt [] <|> pure (programFromOpt progOpt (prgPath $ ccProgram cc) [])

-  -- Check whether the C preprocessor needs -std=gnu99 (only very old toolchains need this)

-  Cc cpp2 <- oneOf "cc doesn't support C99" $ map checkC99Support

-        [ Cc foundCppProg

-        , Cc (foundCppProg & _prgFlags %++ "-std=gnu99")

-        ]

-  let cppProgram = addFlagIfNew "-E" cpp2