-- see Note [Target code interpreter]

   interp <- if

     -- Wasm dynamic linker

     | ArchWasm32 <- platformArch $ targetPlatform dflags

     -> do

         s <- liftIO $ newMVar InterpPending

         loader <- liftIO Loader.uninitializedLoader

         dyld <- liftIO $ makeAbsolute $ topDir dflags </> "dyld.mjs"

         libdir <- liftIO $ last <$> Loader.getGccSearchDirectory logger dflags "libraries"

         let profiled = ways dflags `hasWay` WayProf

             way_tag = if profiled then "_p" else ""

         let cfg =

                   wasmInterpUnitState = ue_homeUnitState $ hsc_unit_env hsc_env

                 }

         pure $ Just $ Interp (ExternalInterp $ ExtWasm $ ExtInterpState cfg s) loader lookup_cache

     -- JavaScript interpreter

     | ArchJavaScript <- platformArch (targetPlatform dflags)

         where

           is_top_arg (Var v) | v `elem` top_args = Just v

           is_top_arg (Cast e _) = is_top_arg e

           is_top_arg _ = Nothing

       where

 import GHC.IfaceToCore  ( typecheckIface, typecheckWholeCoreBindings )

 import GHC.Iface.Make

 import GHC.Iface.Recomp

 import GHC.Iface.Tidy

         -- so we need to call 'getModuleInterface' to load from disk

         case iface of

             Just _  -> return iface

 -- | Check the list of packages are trusted.

   -- only supports dynamic code

  | LinkInMemory <- ghcLink dflags

  , sTargetRTSLinkerOnlySupportsSharedLibs $ settings dflags

  , not (ways dflags `hasWay` WayDyn && gopt Opt_ExternalInterpreter dflags)

     = flip loopNoWarn "Forcing dynamic way because target RTS linker only supports dynamic code" $

         -- See checkOptions, -fexternal-interpreter is

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

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

         setGeneralFlag' Opt_ExternalInterpreter $

         addWay' WayDyn dflags

  | LinkInMemory <- ghcLink dflags

 -- which dominate a large percentage of startup time on Windows.

 getGccSearchDirectory :: Logger -> DynFlags -> String -> IO [FilePath]

 getGccSearchDirectory logger dflags key = do

     cache <- readIORef gccSearchDirCache

     case lookup key cache of

       Just x  -> return x

                               x:_ -> case break (=='=') x of

                                      (_ , [])    -> []

                                      (_, (_:xs)) -> xs

 -- | Get a list of system search directories, this to alleviate pressure on

 -- the findSysDll function.

 data WasmInterpConfig = WasmInterpConfig

   { wasmInterpDyLD           :: !FilePath  -- ^ Location of dyld.mjs script

   , wasmInterpOpts           :: ![String]  -- ^ Additional command line arguments for iserv

   -- wasm ghci browser mode

     The flags below are marked with ``:noindex:`` to avoid duplicate

     ID warnings from Sphinx.

 .. rts-flag:: -hc ⟨name⟩

     :noindex:

     biographies, where ⟨bio⟩ is one of ``lag``, ``drag``, ``void``, or

     ``use``.

 For example, the following options will generate a retainer profile

 restricted to ``Branch`` and ``Leaf`` constructors:

 generatePlatformHostHs :: Expr String

 generatePlatformHostHs = do

     trackGenerateHs

     return $ unlines

         [ "module GHC.Platform.Host where"

         , ""

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

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

             -- for cross GHC.

             , orM [ notM cross, haveCurses ]  `cabalFlag` "terminfo"

             , arg "-build-tool-depends"

             , flag UseLibzstd `cabalFlag` "with-libzstd"

   * Fix issues with toRational for types capable to represent infinite and not-a-number values ([CLC proposal #338](https://github.com/haskell/core-libraries-committee/issues/338))

   * Ensure that `rationalToFloat` and `rationalToDouble` always inline in the end. ([CLC proposal #356](https://github.com/haskell/core-libraries-committee/issues/356))

   * Modify the implementation of `Data.List.sortOn` to use `(>)` instead of `compare`. ([CLC proposal #332](https://github.com/haskell/core-libraries-committee/issues/332))

   * Add `thenA` and `thenM`. ([CLC proposal #351](https://github.com/haskell/core-libraries-committee/issues/351))

   * Fix bug where `naturalAndNot` was incorrectly truncating results ([CLC proposal #350](github.com/haskell/core-libraries-committee/issues/350))

   * Remove extra laziness from `Data.Bifunctor.Bifunctor` instances for all tuples to have the same laziness as their `Data.Functor.Functor` counterparts (i.e. they became more strict than before) ([CLC proposal #339](https://github.com/haskell/core-libraries-committee/issues/339))

       * `GHC.TypeNats.Internal`

       * `GHC.ExecutionStack.Internal`.

   * Deprecate `GHC.JS.Prim.Internal.Build`, as per [CLC #329](https://github.com/haskell/core-libraries-committee/issues/329)

   * Fix incorrect results of `integerPowMod` when the base is 0 and the exponent is negative, and `integerRecipMod` when the modulus is zero ([#26017](https://gitlab.haskell.org/ghc/ghc/-/issues/26017)).

   * Fix the rewrite rule for `scanl'` not being strict in the first element of the output list ([#26143](https://gitlab.haskell.org/ghc/ghc/-/issues/26143)).

     , retainerSelector         :: Maybe String

     , bioSelector              :: Maybe String

     , eraSelector              :: Word -- ^ @since base-4.20.0.0

     } deriving ( Show -- ^ @since base-4.8.0.0

                , Generic -- ^ @since base-4.15.0.0

                )

             <*> (peekCStringOpt =<< #{peek PROFILING_FLAGS, retainerSelector} ptr)

             <*> (peekCStringOpt =<< #{peek PROFILING_FLAGS, bioSelector} ptr)

             <*> #{peek PROFILING_FLAGS, eraSelector} ptr

 getTraceFlags :: IO TraceFlags

 getTraceFlags = do

   js_lookupSymbol :: JSString -> IO (Ptr a)

 lookupSymbolInDLL :: Ptr LoadedDLL -> String -> IO (Maybe (Ptr a))

 resolveObjs :: IO Bool

 resolveObjs = pure True

         $2="$$2 -mcmodel=medium"

         ;;

     esac

     AC_MSG_RESULT([done])

 #include "linker/MMap.h"

 ExecPage *allocateExecPage(void) {

     ExecPage *page = (ExecPage *) mmapAnon(getPageSize());

     return page;

 }

 void freezeExecPage(ExecPage *page) {

     mprotectForLinker(page, getPageSize(), MEM_READ_EXECUTE);

     flushExec(getPageSize(), page);

 }

 void freeExecPage(ExecPage *page) {

     munmapForLinker(page, getPageSize(), "freeExecPage");

 }

 static bool closureSatisfiesConstraints( const StgClosure* p );

 /* ----------------------------------------------------------------------------

  * Find the "closure identity", which is a unique pointer representing

  * the band to which this closure's heap space is attributed in the

 #endif

     case HEAP_BY_CLOSURE_TYPE:

     case HEAP_BY_INFO_TABLE:

         return (void *) (p->header.info);

     default:

         barf("closureIdentity");

     fprintf(fp, "%s", buf);

 }

 bool

 strMatchesSelector( const char* str, const char* sel )

 {

    }

 }

 /* -----------------------------------------------------------------------------

  * Figure out whether a closure should be counted in this census, by

  * testing against all the specified constraints.

 static bool

 closureSatisfiesConstraints( const StgClosure* p )

 {

    // The CCS has a selected field to indicate whether this closure is

    // deselected by not being mentioned in the module, CC, or CCS

        if (!b) return false;

    }

    if (RtsFlags.ProfFlags.eraSelector) {

    }

    if (RtsFlags.ProfFlags.retainerSelector) {

        RetainerSet *rs;

        }

        return false;

    }

 #endif /* PROFILING */

 }

 /* -----------------------------------------------------------------------------

 static void

 recordIPEHeapSample(FILE *hp_file, uint64_t table_id, size_t count)

 {

     char str[100];

     // Emit the profiling sample (convert count to bytes)

     traceHeapProfSampleString(str, count * sizeof(W_));

         switch (RtsFlags.ProfFlags.doHeapProfile) {

         case HEAP_BY_CLOSURE_TYPE:

             traceHeapProfSampleString((char *)ctr->identity,

                                       count * sizeof(W_));

             break;

         case HEAP_BY_CCS:

             fprint_ccs(hp_file, (CostCentreStack *)ctr->identity,

                        RtsFlags.ProfFlags.ccsLength);

             traceHeapProfSampleCostCentre((CostCentreStack *)ctr->identity,

                                           count * sizeof(W_));

             break;

         case HEAP_BY_ERA:

             char str_era[100];

             traceHeapProfSampleString(str_era, count * sizeof(W_));

             break;

         case HEAP_BY_MOD:

         case HEAP_BY_DESCR:

         case HEAP_BY_TYPE:

             traceHeapProfSampleString((char *)ctr->identity,

                                       count * sizeof(W_));

             break;

             // it might be the distinguished retainer set rs_MANY:

             if (rs == &rs_MANY) {

                 fprintf(hp_file, "MANY");

             break;

         }

 #endif

         default:

             barf("dumpCensus; doHeapProfile");

         }

     }

     // Print the unallocated data into the 0 band for info table profiling.

             // size = strlen(tmp);

         }

     }

     traceHeapProfSampleString(tmp, total_size);

 }

 static void read_debug_flags(const char *arg);

 #endif

 static bool read_heap_profiling_flag(const char *arg);

 #if defined(TRACING)

 static void read_trace_flags(const char *arg);

     RtsFlags.ProfFlags.eraSelector        = 0;

 #endif

 #if defined(TRACING)

     RtsFlags.TraceFlags.tracing       = TRACE_NONE;

     RtsFlags.TraceFlags.timestamp     = false;

 "    -hr<cc>...   closures with specified retainers",

 "    -hb<bio>...  closures with specified biographies (lag,drag,void,use)",

 "    -he<era>...  closures with specified era",

 "",

 "  -R<size>       Set the maximum retainer set size (default: 8)",

 "",

 "  -h       Heap residency profile (output file <program>.hp)",

 "  -hT      Produce a heap profile grouped by closure type",

 "  -hi      Produce a heap profile grouped by info table address",

 "  -po<file>  Override profiling output file name prefix (program name by default)",

 #endif /* PROFILING */

 #endif

 #if defined(PROFILING)

 #else

 error = true;

 #endif

                       RtsFlags.CcFlags.outputFileNameStem = rts_argv[arg]+3;

                       break;

                   default:

                 } break;

 #else

                 switch (rts_argv[arg][2]) {

                   case 'a':

                     RtsFlags.CcFlags.doCostCentres = COST_CENTRES_ALL;

               case 'R':

                   OPTION_SAFE;

                       RtsFlags.ProfFlags.maxRetainerSetSize =

                         atof(rts_argv[arg]+2);

                   ) break;

               case 'L':

                   OPTION_SAFE;

                       RtsFlags.ProfFlags.ccsLength = atof(rts_argv[arg]+2);

                       if(RtsFlags.ProfFlags.ccsLength <= 0) {

                         bad_option(rts_argv[arg]);

                       }

                   ) break;

               case 'h': /* serial heap profile */

                 OPTION_SAFE;

                 break;

               case 'i': /* heap sample interval */

                 case 'c': /* Debugging tool: show current cost centre on

                            an exception */

                     OPTION_SAFE;

                         RtsFlags.ProfFlags.showCCSOnException = true;

                         );

                     unchecked_arg_start++;

 }

 #endif

 // Parse a "-h" flag, returning whether the parse resulted in an error.

 static bool read_heap_profiling_flag(const char *arg)

 {

     bool error = false;

         case 'C':

             break;

         case 'M':

             break;

         case 'D':

             break;

         case 'Y':

             break;

             break;

         case 'R':

         case 'r':

         case 'B':

         case 'b':

             break;