    {-
    -----------------------------------------------------------------------------
    --
    -- (c) The University of Glasgow 2001-2003
    --
    -- Access to system tools: gcc, cp, rm etc
    --
    -----------------------------------------------------------------------------
    -}

    {-# LANGUAGE CPP, MultiWayIf, ScopedTypeVariables #-}

    module GHC.SysTools (
            -- * Initialisation
            initSysTools,
            lazyInitLlvmConfig,

            -- * Interface to system tools
            module GHC.SysTools.Tasks,
            module GHC.SysTools.Info,

            linkDynLib,

            copy,
            copyWithHeader,

            -- * General utilities
            Option(..),
            expandTopDir,

            -- * Platform-specifics
            libmLinkOpts,

            -- * Mac OS X frameworks
            getUnitFrameworkOpts,
            getFrameworkOpts
     ) where

    #include "HsVersions.h"

    import GHC.Prelude

    import GHC.Settings.Utils

    import GHC.Unit
    import GHC.Utils.Outputable
    import GHC.Utils.Error
    import GHC.Platform
    import GHC.Driver.Session
    import GHC.Driver.Ways

    import Control.Monad.Trans.Except (runExceptT)
    import System.FilePath
    import System.IO
    import System.IO.Unsafe (unsafeInterleaveIO)
    import GHC.SysTools.ExtraObj
    import GHC.SysTools.Info
    import GHC.SysTools.Tasks
    import GHC.SysTools.BaseDir
    import GHC.Settings.IO
    import qualified Data.Set as Set

    {-
    Note [How GHC finds toolchain utilities]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    GHC.SysTools.initSysProgs figures out exactly where all the auxiliary programs
    are, and initialises mutable variables to make it easy to call them.
    To do this, it makes use of definitions in Config.hs, which is a Haskell
    file containing variables whose value is figured out by the build system.

    Config.hs contains two sorts of things

      cGCC,         The *names* of the programs
      cCPP            e.g.  cGCC = gcc
      cUNLIT                cCPP = gcc -E
      etc           They do *not* include paths

      cUNLIT_DIR   The *path* to the directory containing unlit, split etc
      cSPLIT_DIR   *relative* to the root of the build tree,
                       for use when running *in-place* in a build tree (only)

    ---------------------------------------------
    NOTES for an ALTERNATIVE scheme (i.e *not* what is currently implemented):

    Another hair-brained scheme for simplifying the current tool location
    nightmare in GHC: Simon originally suggested using another
    configuration file along the lines of GCC's specs file - which is fine
    except that it means adding code to read yet another configuration
    file.  What I didn't notice is that the current package.conf is
    general enough to do this:

    Package
        {name = "tools",    import_dirs = [],  source_dirs = [],
         library_dirs = [], hs_libraries = [], extra_libraries = [],
         include_dirs = [], c_includes = [],   package_deps = [],
         extra_ghc_opts = ["-pgmc/usr/bin/gcc","-pgml${topdir}/bin/unlit", ... etc.],
         extra_cc_opts = [], extra_ld_opts = []}

    Which would have the advantage that we get to collect together in one
    place the path-specific package stuff with the path-specific tool
    stuff.
                    End of NOTES
    ---------------------------------------------

    ************************************************************************
    *                                                                      *
    \subsection{Initialisation}
    *                                                                      *
    ************************************************************************
    -}

    -- Note [LLVM configuration]
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    -- The `llvm-targets` and `llvm-passes` files are shipped with GHC and contain
    -- information needed by the LLVM backend to invoke `llc` and `opt`.
    -- Specifically:
    --
    --  * llvm-targets maps autoconf host triples to the corresponding LLVM
    --    `data-layout` declarations. This information is extracted from clang using
    --    the script in utils/llvm-targets/gen-data-layout.sh and should be updated
    --    whenever we target a new version of LLVM.
    --
    --  * llvm-passes maps GHC optimization levels to sets of LLVM optimization
    --    flags that GHC should pass to `opt`.
    --
    -- This information is contained in files rather the GHC source to allow users
    -- to add new targets to GHC without having to recompile the compiler.
    --
    -- Since this information is only needed by the LLVM backend we load it lazily
    -- with unsafeInterleaveIO. Consequently it is important that we lazily pattern
    -- match on LlvmConfig until we actually need its contents.

    lazyInitLlvmConfig :: String
                   -> IO LlvmConfig
    lazyInitLlvmConfig :: String -> IO LlvmConfig
    lazyInitLlvmConfig String
    top_dir
      = IO LlvmConfig -> IO LlvmConfig
    forall a. IO a -> IO a
    unsafeInterleaveIO (IO LlvmConfig -> IO LlvmConfig) -> IO LlvmConfig -> IO LlvmConfig
    forall a b. (a -> b) -> a -> b
    $ do    -- see Note [LLVM configuration]
          [(String, LlvmTarget)]
    targets <- String
    -> ((String, String, String) -> LlvmTarget)
    -> IO [(String, LlvmTarget)]
    forall {f :: * -> *} {f :: * -> *} {a} {b}.
    (Read (f (f a)), Functor f, Functor f) =>
    String -> (a -> b) -> IO (f (f b))
    readAndParse String
    "llvm-targets" (String, String, String) -> LlvmTarget
    mkLlvmTarget
          [(Int, String)]
    passes <- String -> (String -> String) -> IO [(Int, String)]
    forall {f :: * -> *} {f :: * -> *} {a} {b}.
    (Read (f (f a)), Functor f, Functor f) =>
    String -> (a -> b) -> IO (f (f b))
    readAndParse String
    "llvm-passes" String -> String
    forall a. a -> a
    id
          LlvmConfig -> IO LlvmConfig
    forall (m :: * -> *) a. Monad m => a -> m a
    return (LlvmConfig -> IO LlvmConfig) -> LlvmConfig -> IO LlvmConfig
    forall a b. (a -> b) -> a -> b
    $ LlvmConfig :: [(String, LlvmTarget)] -> [(Int, String)] -> LlvmConfig
    LlvmConfig { llvmTargets :: [(String, LlvmTarget)]
    llvmTargets = [(String, LlvmTarget)]
    targets, llvmPasses :: [(Int, String)]
    llvmPasses = [(Int, String)]
    passes }
      where
        readAndParse :: String -> (a -> b) -> IO (f (f b))
    readAndParse String
    name a -> b
    builder =
          do let llvmConfigFile :: String
    llvmConfigFile = String
    top_dir String -> String -> String
    </> String
    name
             String
    llvmConfigStr <- String -> IO String
    readFile String
    llvmConfigFile
             case String -> Maybe (f (f a))
    forall a. Read a => String -> Maybe a
    maybeReadFuzzy String
    llvmConfigStr of
               Just f (f a)
    s -> f (f b) -> IO (f (f b))
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> b
    builder (f a -> f b) -> f (f a) -> f (f b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f (f a)
    s)
               Maybe (f (f a))
    Nothing -> String -> IO (f (f b))
    forall a. String -> a
    pgmError (String
    "Can't parse " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String -> String
    forall a. Show a => a -> String
    show String
    llvmConfigFile)

        mkLlvmTarget :: (String, String, String) -> LlvmTarget
        mkLlvmTarget :: (String, String, String) -> LlvmTarget
    mkLlvmTarget (String
    dl, String
    cpu, String
    attrs) = String -> String -> [String] -> LlvmTarget
    LlvmTarget String
    dl String
    cpu (String -> [String]
    words String
    attrs)

    initSysTools :: String          -- TopDir path
                 -> IO Settings     -- Set all the mutable variables above, holding
                                    --      (a) the system programs
                                    --      (b) the package-config file
                                    --      (c) the GHC usage message
    initSysTools :: String -> IO Settings
    initSysTools String
    top_dir = do
      Either SettingsError Settings
    res <- ExceptT SettingsError IO Settings
    -> IO (Either SettingsError Settings)
    forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
    runExceptT (ExceptT SettingsError IO Settings
     -> IO (Either SettingsError Settings))
    -> ExceptT SettingsError IO Settings
    -> IO (Either SettingsError Settings)
    forall a b. (a -> b) -> a -> b
    $ String -> ExceptT SettingsError IO Settings
    forall (m :: * -> *).
    MonadIO m =>
    String -> ExceptT SettingsError m Settings
    initSettings String
    top_dir
      case Either SettingsError Settings
    res of
        Right Settings
    a -> Settings -> IO Settings
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Settings
    a
        Left (SettingsError_MissingData String
    msg) -> String -> IO Settings
    forall a. String -> a
    pgmError String
    msg
        Left (SettingsError_BadData String
    msg) -> String -> IO Settings
    forall a. String -> a
    pgmError String
    msg

    {- Note [Windows stack usage]

    See: #8870 (and #8834 for related info) and #12186

    On Windows, occasionally we need to grow the stack. In order to do
    this, we would normally just bump the stack pointer - but there's a
    catch on Windows.

    If the stack pointer is bumped by more than a single page, then the
    pages between the initial pointer and the resulting location must be
    properly committed by the Windows virtual memory subsystem. This is
    only needed in the event we bump by more than one page (i.e 4097 bytes
    or more).

    Windows compilers solve this by emitting a call to a special function
    called _chkstk, which does this committing of the pages for you.

    The reason this was causing a segfault was because due to the fact the
    new code generator tends to generate larger functions, we needed more
    stack space in GHC itself. In the x86 codegen, we needed approximately
    ~12kb of stack space in one go, which caused the process to segfault,
    as the intervening pages were not committed.

    GCC can emit such a check for us automatically but only when the flag
    -fstack-check is used.

    See https://gcc.gnu.org/onlinedocs/gnat_ugn/Stack-Overflow-Checking.html
    for more information.

    -}

    copy :: DynFlags -> String -> FilePath -> FilePath -> IO ()
    copy :: DynFlags -> String -> String -> String -> IO ()
    copy DynFlags
    dflags String
    purpose String
    from String
    to = DynFlags -> String -> Maybe String -> String -> String -> IO ()
    copyWithHeader DynFlags
    dflags String
    purpose Maybe String
    forall a. Maybe a
    Nothing String
    from String
    to

    copyWithHeader :: DynFlags -> String -> Maybe String -> FilePath -> FilePath
                   -> IO ()
    copyWithHeader :: DynFlags -> String -> Maybe String -> String -> String -> IO ()
    copyWithHeader DynFlags
    dflags String
    purpose Maybe String
    maybe_header String
    from String
    to = do
      DynFlags -> String -> IO ()
    showPass DynFlags
    dflags String
    purpose

      Handle
    hout <- String -> IOMode -> IO Handle
    openBinaryFile String
    to   IOMode
    WriteMode
      Handle
    hin  <- String -> IOMode -> IO Handle
    openBinaryFile String
    from IOMode
    ReadMode
      String
    ls <- Handle -> IO String
    hGetContents Handle
    hin -- inefficient, but it'll do for now. ToDo: speed up
      IO () -> (String -> IO ()) -> Maybe String -> IO ()
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe (() -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()) (Handle -> String -> IO ()
    header Handle
    hout) Maybe String
    maybe_header
      Handle -> String -> IO ()
    hPutStr Handle
    hout String
    ls
      Handle -> IO ()
    hClose Handle
    hout
      Handle -> IO ()
    hClose Handle
    hin
     where
      -- write the header string in UTF-8.  The header is something like
      --   {-# LINE "foo.hs" #-}
      -- and we want to make sure a Unicode filename isn't mangled.
      header :: Handle -> String -> IO ()
    header Handle
    h String
    str = do
       Handle -> TextEncoding -> IO ()
    hSetEncoding Handle
    h TextEncoding
    utf8
       Handle -> String -> IO ()
    hPutStr Handle
    h String
    str
       Handle -> Bool -> IO ()
    hSetBinaryMode Handle
    h Bool
    True

    {-
    ************************************************************************
    *                                                                      *
    \subsection{Support code}
    *                                                                      *
    ************************************************************************
    -}

    linkDynLib :: DynFlags -> [String] -> [UnitId] -> IO ()
    linkDynLib :: DynFlags -> [String] -> [UnitId] -> IO ()
    linkDynLib DynFlags
    dflags0 [String]
    o_files [UnitId]
    dep_packages
     = do
        let -- This is a rather ugly hack to fix dynamically linked
            -- GHC on Windows. If GHC is linked with -threaded, then
            -- it links against libHSrts_thr. But if base is linked
            -- against libHSrts, then both end up getting loaded,
            -- and things go wrong. We therefore link the libraries
            -- with the same RTS flags that we link GHC with.
            dflags1 :: DynFlags
    dflags1 = if PlatformMisc -> Bool
    platformMisc_ghcThreaded (PlatformMisc -> Bool) -> PlatformMisc -> Bool
    forall a b. (a -> b) -> a -> b
    $ DynFlags -> PlatformMisc
    platformMisc DynFlags
    dflags0
              then Way -> DynFlags -> DynFlags
    addWay' Way
    WayThreaded DynFlags
    dflags0
              else                     DynFlags
    dflags0
            dflags :: DynFlags
    dflags = if PlatformMisc -> Bool
    platformMisc_ghcDebugged (PlatformMisc -> Bool) -> PlatformMisc -> Bool
    forall a b. (a -> b) -> a -> b
    $ DynFlags -> PlatformMisc
    platformMisc DynFlags
    dflags1
              then Way -> DynFlags -> DynFlags
    addWay' Way
    WayDebug DynFlags
    dflags1
              else                  DynFlags
    dflags1

            verbFlags :: [String]
    verbFlags = DynFlags -> [String]
    getVerbFlags DynFlags
    dflags
            o_file :: Maybe String
    o_file = DynFlags -> Maybe String
    outputFile DynFlags
    dflags

        [UnitInfo]
    pkgs <- DynFlags -> [UnitId] -> IO [UnitInfo]
    getPreloadUnitsAnd DynFlags
    dflags [UnitId]
    dep_packages

        let platform :: Platform
    platform = DynFlags -> Platform
    targetPlatform DynFlags
    dflags
            os :: OS
    os = Platform -> OS
    platformOS Platform
    platform
        let pkg_lib_paths :: [String]
    pkg_lib_paths = DynFlags -> [UnitInfo] -> [String]
    collectLibraryPaths DynFlags
    dflags [UnitInfo]
    pkgs
        let pkg_lib_path_opts :: [String]
    pkg_lib_path_opts = (String -> [String]) -> [String] -> [String]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap String -> [String]
    get_pkg_lib_path_opts [String]
    pkg_lib_paths
            get_pkg_lib_path_opts :: String -> [String]
    get_pkg_lib_path_opts String
    l
             | ( OS -> Bool
    osElfTarget (Platform -> OS
    platformOS (DynFlags -> Platform
    targetPlatform DynFlags
    dflags)) Bool -> Bool -> Bool
    ||
                 OS -> Bool
    osMachOTarget (Platform -> OS
    platformOS (DynFlags -> Platform
    targetPlatform DynFlags
    dflags)) ) Bool -> Bool -> Bool
    &&
               DynFlags -> DynLibLoader
    dynLibLoader DynFlags
    dflags DynLibLoader -> DynLibLoader -> Bool
    forall a. Eq a => a -> a -> Bool
    == DynLibLoader
    SystemDependent Bool -> Bool -> Bool
    &&
               -- Only if we want dynamic libraries
               Way
    WayDyn Way -> Set Way -> Bool
    forall a. Ord a => a -> Set a -> Bool
    `Set.member` DynFlags -> Set Way
    ways DynFlags
    dflags Bool -> Bool -> Bool
    &&
               -- Only use RPath if we explicitly asked for it
               DynFlags -> OS -> Bool
    useXLinkerRPath DynFlags
    dflags OS
    os
                = [String
    "-L" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    l, String
    "-Xlinker", String
    "-rpath", String
    "-Xlinker", String
    l]
                  -- See Note [-Xlinker -rpath vs -Wl,-rpath]
             | Bool
    otherwise = [String
    "-L" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    l]

        let lib_paths :: [String]
    lib_paths = DynFlags -> [String]
    libraryPaths DynFlags
    dflags
        let lib_path_opts :: [String]
    lib_path_opts = (String -> String) -> [String] -> [String]
    forall a b. (a -> b) -> [a] -> [b]
    map (String
    "-L"String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++) [String]
    lib_paths

        -- We don't want to link our dynamic libs against the RTS package,
        -- because the RTS lib comes in several flavours and we want to be
        -- able to pick the flavour when a binary is linked.
        -- On Windows we need to link the RTS import lib as Windows does
        -- not allow undefined symbols.
        -- The RTS library path is still added to the library search path
        -- above in case the RTS is being explicitly linked in (see #3807).
        let pkgs_no_rts :: [UnitInfo]
    pkgs_no_rts = case OS
    os of
                          OS
    OSMinGW32 ->
                              [UnitInfo]
    pkgs
                          OS
    _ | GeneralFlag -> DynFlags -> Bool
    gopt GeneralFlag
    Opt_LinkRts DynFlags
    dflags ->
                              [UnitInfo]
    pkgs
                            | Bool
    otherwise ->
                              (UnitInfo -> Bool) -> [UnitInfo] -> [UnitInfo]
    forall a. (a -> Bool) -> [a] -> [a]
    filter ((UnitId -> UnitId -> Bool
    forall a. Eq a => a -> a -> Bool
    /= UnitId
    rtsUnitId) (UnitId -> Bool) -> (UnitInfo -> UnitId) -> UnitInfo -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . UnitInfo -> UnitId
    forall compid srcpkgid srcpkgname uid modulename mod.
    GenericUnitInfo compid srcpkgid srcpkgname uid modulename mod
    -> uid
    unitId) [UnitInfo]
    pkgs
        let pkg_link_opts :: [String]
    pkg_link_opts = let ([String]
    package_hs_libs, [String]
    extra_libs, [String]
    other_flags) = DynFlags -> [UnitInfo] -> ([String], [String], [String])
    collectLinkOpts DynFlags
    dflags [UnitInfo]
    pkgs_no_rts
                            in  [String]
    package_hs_libs [String] -> [String] -> [String]
    forall a. [a] -> [a] -> [a]
    ++ [String]
    extra_libs [String] -> [String] -> [String]
    forall a. [a] -> [a] -> [a]
    ++ [String]
    other_flags

            -- probably _stub.o files
            -- and last temporary shared object file
        let extra_ld_inputs :: [Option]
    extra_ld_inputs = DynFlags -> [Option]
    ldInputs DynFlags
    dflags

        -- frameworks
        [String]
    pkg_framework_opts <- DynFlags -> Platform -> [UnitId] -> IO [String]
    getUnitFrameworkOpts DynFlags
    dflags Platform
    platform
                                                  ((UnitInfo -> UnitId) -> [UnitInfo] -> [UnitId]
    forall a b. (a -> b) -> [a] -> [b]
    map UnitInfo -> UnitId
    forall compid srcpkgid srcpkgname uid modulename mod.
    GenericUnitInfo compid srcpkgid srcpkgname uid modulename mod
    -> uid
    unitId [UnitInfo]
    pkgs)
        let framework_opts :: [String]
    framework_opts = DynFlags -> Platform -> [String]
    getFrameworkOpts DynFlags
    dflags Platform
    platform

        case OS
    os of
            OS
    OSMinGW32 -> do
                -------------------------------------------------------------
                -- Making a DLL
                -------------------------------------------------------------
                let output_fn :: String
    output_fn = case Maybe String
    o_file of
                                Just String
    s -> String
    s
                                Maybe String
    Nothing -> String
    "HSdll.dll"

                DynFlags -> [Option] -> IO ()
    runLink DynFlags
    dflags (
                        (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    verbFlags
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [ String -> Option
    Option String
    "-o"
                        , String -> String -> Option
    FileOption String
    "" String
    output_fn
                        , String -> Option
    Option String
    "-shared"
                        ] [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++
                        [ String -> String -> Option
    FileOption String
    "-Wl,--out-implib=" (String
    output_fn String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    ".a")
                        | GeneralFlag -> DynFlags -> Bool
    gopt GeneralFlag
    Opt_SharedImplib DynFlags
    dflags
                        ]
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map (String -> String -> Option
    FileOption String
    "") [String]
    o_files

                     -- Permit the linker to auto link _symbol to _imp_symbol
                     -- This lets us link against DLLs without needing an "import library"
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [String -> Option
    Option String
    "-Wl,--enable-auto-import"]

                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [Option]
    extra_ld_inputs
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option (
                        [String]
    lib_path_opts
                     [String] -> [String] -> [String]
    forall a. [a] -> [a] -> [a]
    ++ [String]
    pkg_lib_path_opts
                     [String] -> [String] -> [String]
    forall a. [a] -> [a] -> [a]
    ++ [String]
    pkg_link_opts
                    ))
            OS
    _ | OS
    os OS -> OS -> Bool
    forall a. Eq a => a -> a -> Bool
    == OS
    OSDarwin -> do
                -------------------------------------------------------------------
                -- Making a darwin dylib
                -------------------------------------------------------------------
                -- About the options used for Darwin:
                -- -dynamiclib
                --   Apple's way of saying -shared
                -- -undefined dynamic_lookup:
                --   Without these options, we'd have to specify the correct
                --   dependencies for each of the dylibs. Note that we could
                --   (and should) do without this for all libraries except
                --   the RTS; all we need to do is to pass the correct
                --   HSfoo_dyn.dylib files to the link command.
                --   This feature requires Mac OS X 10.3 or later; there is
                --   a similar feature, -flat_namespace -undefined suppress,
                --   which works on earlier versions, but it has other
                --   disadvantages.
                -- -single_module
                --   Build the dynamic library as a single "module", i.e. no
                --   dynamic binding nonsense when referring to symbols from
                --   within the library. The NCG assumes that this option is
                --   specified (on i386, at least).
                -- -install_name
                --   Mac OS/X stores the path where a dynamic library is (to
                --   be) installed in the library itself.  It's called the
                --   "install name" of the library. Then any library or
                --   executable that links against it before it's installed
                --   will search for it in its ultimate install location.
                --   By default we set the install name to the absolute path
                --   at build time, but it can be overridden by the
                --   -dylib-install-name option passed to ghc. Cabal does
                --   this.
                -------------------------------------------------------------------

                let output_fn :: String
    output_fn = case Maybe String
    o_file of { Just String
    s -> String
    s; Maybe String
    Nothing -> String
    "a.out"; }

                String
    instName <- case DynFlags -> Maybe String
    dylibInstallName DynFlags
    dflags of
                    Just String
    n -> String -> IO String
    forall (m :: * -> *) a. Monad m => a -> m a
    return String
    n
                    Maybe String
    Nothing -> String -> IO String
    forall (m :: * -> *) a. Monad m => a -> m a
    return (String -> IO String) -> String -> IO String
    forall a b. (a -> b) -> a -> b
    $ String
    "@rpath" String -> String -> String
    `combine` (String -> String
    takeFileName String
    output_fn)
                DynFlags -> [Option] -> IO ()
    runLink DynFlags
    dflags (
                        (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    verbFlags
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [ String -> Option
    Option String
    "-dynamiclib"
                        , String -> Option
    Option String
    "-o"
                        , String -> String -> Option
    FileOption String
    "" String
    output_fn
                        ]
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    o_files
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [ String -> Option
    Option String
    "-undefined",
                          String -> Option
    Option String
    "dynamic_lookup",
                          String -> Option
    Option String
    "-single_module" ]
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (if Platform -> Arch
    platformArch Platform
    platform Arch -> [Arch] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [ Arch
    ArchX86_64, Arch
    ArchAArch64 ]
                         then [ ]
                         else [ String -> Option
    Option String
    "-Wl,-read_only_relocs,suppress" ])
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [ String -> Option
    Option String
    "-install_name", String -> Option
    Option String
    instName ]
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    lib_path_opts
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [Option]
    extra_ld_inputs
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    framework_opts
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    pkg_lib_path_opts
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    pkg_link_opts
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    pkg_framework_opts
                     -- dead_strip_dylibs, will remove unused dylibs, and thus save
                     -- space in the load commands. The -headerpad is necessary so
                     -- that we can inject more @rpath's later for the leftover
                     -- libraries in the runInjectRpaths phase below.
                     --
                     -- See Note [Dynamic linking on macOS]
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [ String -> Option
    Option String
    "-Wl,-dead_strip_dylibs", String -> Option
    Option String
    "-Wl,-headerpad,8000" ]
                  )
                DynFlags -> [String] -> String -> IO ()
    runInjectRPaths DynFlags
    dflags [String]
    pkg_lib_paths String
    output_fn
            OS
    _ -> do
                -------------------------------------------------------------------
                -- Making a DSO
                -------------------------------------------------------------------

                let output_fn :: String
    output_fn = case Maybe String
    o_file of { Just String
    s -> String
    s; Maybe String
    Nothing -> String
    "a.out"; }
                    unregisterised :: Bool
    unregisterised = Platform -> Bool
    platformUnregisterised (DynFlags -> Platform
    targetPlatform DynFlags
    dflags)
                let bsymbolicFlag :: [String]
    bsymbolicFlag = -- we need symbolic linking to resolve
                                    -- non-PIC intra-package-relocations for
                                    -- performance (where symbolic linking works)
                                    -- See Note [-Bsymbolic assumptions by GHC]
                                    [String
    "-Wl,-Bsymbolic" | Bool -> Bool
    not Bool
    unregisterised]

                DynFlags -> [Option] -> IO ()
    runLink DynFlags
    dflags (
                        (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    verbFlags
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [Option]
    libmLinkOpts
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [ String -> Option
    Option String
    "-o"
                        , String -> String -> Option
    FileOption String
    "" String
    output_fn
                        ]
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    o_files
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [ String -> Option
    Option String
    "-shared" ]
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    bsymbolicFlag
                        -- Set the library soname. We use -h rather than -soname as
                        -- Solaris 10 doesn't support the latter:
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [ String -> Option
    Option (String
    "-Wl,-h," String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String -> String
    takeFileName String
    output_fn) ]
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ [Option]
    extra_ld_inputs
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    lib_path_opts
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    pkg_lib_path_opts
                     [Option] -> [Option] -> [Option]
    forall a. [a] -> [a] -> [a]
    ++ (String -> Option) -> [String] -> [Option]
    forall a b. (a -> b) -> [a] -> [b]
    map String -> Option
    Option [String]
    pkg_link_opts
                  )

    -- | Some platforms require that we explicitly link against @libm@ if any
    -- math-y things are used (which we assume to include all programs). See #14022.
    libmLinkOpts :: [Option]
    libmLinkOpts :: [Option]
    libmLinkOpts =
    #if defined(HAVE_LIBM)
      [Option "-lm"]
    #else
      []
    #endif

    getUnitFrameworkOpts :: DynFlags -> Platform -> [UnitId] -> IO [String]
    getUnitFrameworkOpts :: DynFlags -> Platform -> [UnitId] -> IO [String]
    getUnitFrameworkOpts DynFlags
    dflags Platform
    platform [UnitId]
    dep_packages
      | Platform -> Bool
    platformUsesFrameworks Platform
    platform = do
        [String]
    pkg_framework_path_opts <- do
            [String]
    pkg_framework_paths <- DynFlags -> [UnitId] -> IO [String]
    getUnitFrameworkPath DynFlags
    dflags [UnitId]
    dep_packages
            [String] -> IO [String]
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([String] -> IO [String]) -> [String] -> IO [String]
    forall a b. (a -> b) -> a -> b
    $ (String -> String) -> [String] -> [String]
    forall a b. (a -> b) -> [a] -> [b]
    map (String
    "-F" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++) [String]
    pkg_framework_paths

        [String]
    pkg_framework_opts <- do
            [String]
    pkg_frameworks <- DynFlags -> [UnitId] -> IO [String]
    getUnitFrameworks DynFlags
    dflags [UnitId]
    dep_packages
            [String] -> IO [String]
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([String] -> IO [String]) -> [String] -> IO [String]
    forall a b. (a -> b) -> a -> b
    $ [[String]] -> [String]
    forall (t :: * -> *) a. Foldable t => t [a] -> [a]
    concat [ [String
    "-framework", String
    fw] | String
    fw <- [String]
    pkg_frameworks ]

        [String] -> IO [String]
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([String]
    pkg_framework_path_opts [String] -> [String] -> [String]
    forall a. [a] -> [a] -> [a]
    ++ [String]
    pkg_framework_opts)

      | Bool
    otherwise = [String] -> IO [String]
    forall (m :: * -> *) a. Monad m => a -> m a
    return []

    getFrameworkOpts :: DynFlags -> Platform -> [String]
    getFrameworkOpts :: DynFlags -> Platform -> [String]
    getFrameworkOpts DynFlags
    dflags Platform
    platform
      | Platform -> Bool
    platformUsesFrameworks Platform
    platform = [String]
    framework_path_opts [String] -> [String] -> [String]
    forall a. [a] -> [a] -> [a]
    ++ [String]
    framework_opts
      | Bool
    otherwise = []
      where
        framework_paths :: [String]
    framework_paths     = DynFlags -> [String]
    frameworkPaths DynFlags
    dflags
        framework_path_opts :: [String]
    framework_path_opts = (String -> String) -> [String] -> [String]
    forall a b. (a -> b) -> [a] -> [b]
    map (String
    "-F" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++) [String]
    framework_paths

        frameworks :: [String]
    frameworks     = DynFlags -> [String]
    cmdlineFrameworks DynFlags
    dflags
        -- reverse because they're added in reverse order from the cmd line:
        framework_opts :: [String]
    framework_opts = [[String]] -> [String]
    forall (t :: * -> *) a. Foldable t => t [a] -> [a]
    concat [ [String
    "-framework", String
    fw]
                                | String
    fw <- [String] -> [String]
    forall a. [a] -> [a]
    reverse [String]
    frameworks ]

    {-
    Note [-Bsymbolic assumptions by GHC]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    GHC has a few assumptions about interaction of relocations in NCG and linker:

    1. -Bsymbolic resolves internal references when the shared library is linked,
       which is important for performance.
    2. When there is a reference to data in a shared library from the main program,
       the runtime linker relocates the data object into the main program using an
       R_*_COPY relocation.
    3. If we used -Bsymbolic, then this results in multiple copies of the data
       object, because some references have already been resolved to point to the
       original instance. This is bad!

    We work around [3.] for native compiled code by avoiding the generation of
    R_*_COPY relocations.

    Unregisterised compiler can't evade R_*_COPY relocations easily thus we disable
    -Bsymbolic linking there.

    See related tickets: #4210, #15338
    -}