-- an unnamed Haskell package. This corresponds on Windows/PE to

         -- __declspec(dllimport) in C.

         | 'extern' NAME

         -- A data label imported from another unamed shared library.

         -- This corresponds on Windows/PE to __declspec(dllimport) in C (but

         -- cmm doesn't know about data vs function symbols so we have to say).

         | 'extern' 'DATA' NAME

         -- A code label imported from the shared library for a Haskell package

         -- with the given UnitId. Such labels behave as local when used within

         -- the specified unit, or as extern otherwise.

         | STRING NAME

         -- A data label imported from the shared library for a Haskell package

         -- with the given UnitId. Such labels behave as local when used within

         -- the specified unit, or as extern otherwise.

         | STRING 'DATA' NAME

 names   :: { [FastString] }

        ("target has RTS linker",       showBool $ platformHasRTSLinker platform),

        ("Target default backend",      show     $ platformDefaultBackend platform),

        -- Whether or not we support @-dynamic-too@

        -- Whether or not we support the @-j@ flag with @--make@.

        ("Support parallel --make",     "YES"),

        -- Whether or not we support "Foo from foo-0.1-XXX:Foo" syntax in

     showBool True  = "YES"

     showBool False = "NO"

     platform  = targetPlatform dflags

     expandDirectories = expandToolDir (toolDir dflags) . expandTopDir (topDir dflags)

     query :: (Target -> a) -> a

     query f = f (rawTarget dflags)

 -- ensure that a later change doesn't invalidate an earlier check.

 -- Be careful not to introduce potential loops!

 makeDynFlagsConsistent dflags

  -- Disable -dynamic-too if we are are compiling with -dynamic already, otherwise

  -- you get two dynamic object files (.o and .dyn_o). (#20436)

  | ways dflags `hasWay` WayDyn && gopt Opt_BuildDynamicToo dflags

          go other               = other

 -- | Do we allow the given top-level (static) ConApp?

 allowTopLevelConApp

   :: Platform

   -> Bool          -- is Opt_ExternalDynamicRefs enabled?

 allowTopLevelConApp platform ext_dyn_refs this_mod con args

   -- we're not using dynamic linking

   | not ext_dyn_refs = True

   -- otherwise, allowed

   -- Sylvain: shouldn't this be False when (ext_dyn_refs && is_external_con_app)?

   | otherwise = True

 -- True of machine addresses; these are the things that don't work across DLLs.

 -- The key point here is that VoidRep comes out False, so that a top level

                 Haddock BuildPackage -> runHaddock path buildArgs buildInputs

                 HsCpp    -> captureStdout

     writeFile' tmp $ escapeArgs fileInputs

     cmd [haddockPath] flagArgs ('@' : tmp)

 -- TODO: Some builders are required only on certain platforms. For example,

 -- 'Objdump' is only required on OpenBSD and AIX. Add support for platform

 -- | This data structure captures all information relevant to invoking a builder.

 data BuildInfo = BuildInfo {

     buildArgs :: [String],

     -- | Input files.

     buildInputs :: [FilePath],

 platformSupportsSharedLibs :: Action Bool

 -- FIXME: This is querying about the target but is named "platformXXX", targetSupportsSharedLibs would be better

 platformSupportsSharedLibs = do

     ppc_linux     <- (&&) <$> anyTargetArch [ ArchPPC ] <*> anyTargetOs [ OSLinux ]

     solaris       <- (&&) <$> anyTargetArch [ ArchX86 ] <*> anyTargetOs [ OSSolaris2 ]

     javascript    <- anyTargetArch     [ ArchJavaScript ]

 -- | Does the target support threaded RTS?

 targetSupportsThreadedRts :: Action Bool

 import Hadrian.Expression

 import Hadrian.Haskell.Cabal

 import Packages

 import Settings

 import Target

 import Utilities

 -- * Registering

 registerPackages :: [Context] -> Action ()

     need =<< mapM pkgRegisteredLibraryFile ctxs

 -- | Register a package and initialise the corresponding package database if

 -- need be. Note that we only register packages in 'Stage0' and 'Stage1'.

 registerPackageRules :: [(Resource, Int)] -> Stage -> Inplace -> Rules ()

 import Hadrian.Utilities

 import Settings.Builders.Common

 -- library files (see Rules.Library.libraryRules).

 rtsRules :: Rules ()

 rtsRules = priority 3 $ do

     root <- buildRootRules

     -- Solve the recursive dependency between the rts and ghc-internal

     -- on Windows by creating an import lib for the ghc-internal dll,

     -- to be linked into the rts dll.

         output = target -- the .dll.a import lib

     need [input]

     runBuilder Dlltool ["-d", input, "-l", output] [input] [output]

                   [ arg "-fwrite-ide-info"

                   , arg "-hiedir", arg hie_path

                   ]

             , arg "-o", arg =<< getOutput ]

 compileC :: Args

             , mconcat (map (map ("-optc" ++) <$>) ccArgs)

             , defaultGhcWarningsArgs

             , arg "-c"

             , arg "-o"

             , arg =<< getOutput ]

             , mconcat (map (map ("-optcxx" ++) <$>) ccArgs)

             , defaultGhcWarningsArgs

             , arg "-c"

             , arg "-o"

             , arg =<< getOutput ]

 import Settings.Builders.RunTest

 import Settings.Builders.Xelatex

 import Settings.Packages

 import Settings.Warnings

 import qualified Hadrian.Builder.Git

 import Settings.Builders.Win32Tarballs

 -- * We build 'profiling' way when stage > Stage0.

 -- * We build 'dynamic' way when stage > Stage0 and the platform supports it.

 defaultLibraryWays :: Ways

 -- | Default build ways for the RTS.

 defaultRtsWays :: Ways

 defaultDynamicGhcPrograms :: Action Bool

 defaultDynamicGhcPrograms = do

   supportsShared <- platformSupportsSharedLibs

 -- | All 'Builder'-dependent command line arguments.

 defaultBuilderArgs :: Args

           , Profiling `wayUnit` way          ? arg "-DPROFILING"

           , Threaded  `wayUnit` way          ? arg "-DTHREADED_RTS"

           , notM targetSupportsSMP           ? arg "-optc-DNOSMP"

             -- See Note [AutoApply.cmm for vectors] in genapply/Main.hs

             --

 module Settings.Program

   ( programContext

   , ghcWithInterpreter

   ) where

 -- get a context/contexts for a given stage and package.

 programContext :: Stage -> Package -> Action Context

 programContext stage pkg = do

 -- | When cross compiling, enable for stage0 to get ghci

 -- support. But when not cross compiling, disable for

 #include "sm/GC.h" // for evac_fn

 #include "BeginPrivate.h"

 /* The ./configure gives us a set of CPP flags, one for each named I/O manager:

 /* Global var to tell us which I/O manager impl we are using */

 extern IOManagerType iomgr_type;

 /* The CapIOManager is the per-capability data structure belonging to the I/O

  * manager. It is defined in full in IOManagerInternals.h. The opaque forward

     symhash = allocStrHashTable();

     /* populate the symbol table with stuff from the RTS */

     /* Add extra symbols. rtsExtraSyms() is a weakly defined symbol in the rts,

      * that can be overrided by linking in an object with a corresponding

 #include "ghcplatform.h"

 #include "Rts.h"

 #include "RtsSymbols.h"

 #include "TopHandler.h"

 #include "HsFFI.h"

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

  * Symbols to be inserted into the RTS symbol table.

  */

 #define Maybe_Stable_Names      SymI_HasProto(stg_mkWeakzh)                   \

       SymI_HasProto(stg_asyncWritezh)                    \

       SymI_HasProto(stg_asyncDoProczh)                   \

       SymI_HasProto(rts_InstallConsoleEvent)             \

       SymI_HasProto(rts_ConsoleHandlerDone)              \

       SymI_NeedsProto(__mingw_module_is_dll)             \

       RTS_WIN64_ONLY(SymI_NeedsProto(___chkstk_ms))      \

       SymI_HasProto(freeExecPage)                                       \

       SymI_HasProto(getAllocations)                                     \

       SymI_HasProto(revertCAFs)                                         \

       SymI_NeedsDataProto(rts_breakpoint_io_action)                     \

       SymI_NeedsDataProto(rts_stop_next_breakpoint)                     \

       SymI_NeedsDataProto(rts_stop_on_exception)                        \

       SymI_NeedsProto(rts_enableStopAfterReturn)                        \

       SymI_NeedsProto(rts_disableStopAfterReturn)                       \

       SymI_HasProto(stopTimer)                                          \

       SymI_HasDataProto(stg_traceEventzh)                                   \

       SymI_HasDataProto(stg_traceMarkerzh)                                  \

       SymI_HasDataProto(stg_traceBinaryEventzh)                             \

       SymI_HasProto(hs_word2float64)

 #define SymI_HasProto(vvv) /**/

 #define SymI_HasDataProto(vvv) /**/

 #define SymI_HasProto_redirect(vvv,xxx,strength,ty) /**/

 #undef SymE_NeedsProto

 #undef SymE_NeedsDataProto

 #define SymI_HasProto(vvv) { MAYBE_LEADING_UNDERSCORE_STR(#vvv), \

                     (void*)(&(vvv)), STRENGTH_NORMAL, SYM_TYPE_CODE },

 #define SymI_HasDataProto(vvv) { MAYBE_LEADING_UNDERSCORE_STR(#vvv), \

     { MAYBE_LEADING_UNDERSCORE_STR(#vvv),    \

       (void*)(&(xxx)), strength, ty },

       RTS_SYMBOLS

       RTS_RET_SYMBOLS

       RTS_POSIX_ONLY_SYMBOLS

       RTS_SYMBOLS_PRIM

       SymI_HasDataProto(nonmoving_write_barrier_enabled)

       { 0, 0, STRENGTH_NORMAL, SYM_TYPE_CODE } /* sentinel */

 // Note [Extra RTS symbols]

 #pragma once

 #include "ghcautoconf.h"

 #if defined(LEADING_UNDERSCORE)

 #define MAYBE_LEADING_UNDERSCORE_STR(s) ("_" s)

     SymType type;

 } RtsSymbolVal;

 extern RtsSymbolVal* __attribute__((weak)) rtsExtraSyms(void);