    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE LambdaCase #-}

    -- | Platform description
    module GHC.Platform
       ( Platform (..)
       , PlatformWordSize(..)
       , platformArch
       , platformOS
       , ArchOS(..)
       , Arch(..)
       , OS(..)
       , ArmISA(..)
       , ArmISAExt(..)
       , ArmABI(..)
       , PPC_64ABI(..)
       , ByteOrder(..)
       , target32Bit
       , isARM
       , isPPC
       , osElfTarget
       , osMachOTarget
       , osSubsectionsViaSymbols
       , platformUsesFrameworks
       , platformWordSizeInBytes
       , platformWordSizeInBits
       , platformMinInt
       , platformMaxInt
       , platformMaxWord
       , platformInIntRange
       , platformInWordRange
       , platformCConvNeedsExtension
       , platformHasRTSLinker
       , PlatformMisc(..)
       , SseVersion (..)
       , BmiVersion (..)
       , wordAlignment
       -- * SSE and AVX
       , isSseEnabled
       , isSse2Enabled
       -- * Platform constants
       , PlatformConstants(..)
       , lookupPlatformConstants
       , platformConstants
       -- * Shared libraries
       , platformSOName
       , platformHsSOName
       , platformSOExt
       , genericPlatform
       )
    where

    import Prelude -- See Note [Why do we import Prelude here?]

    import GHC.Read
    import GHC.ByteOrder (ByteOrder(..))
    import GHC.Platform.Constants
    import GHC.Platform.ArchOS
    import GHC.Types.Basic (Alignment, alignmentOf)
    import GHC.Utils.Panic.Plain

    import Data.Word
    import Data.Int
    import System.FilePath
    import System.Directory

    -- | Platform description
    --
    -- This is used to describe platforms so that we can generate code for them.
    data Platform = Platform
       { Platform -> ArchOS
    platformArchOS                   :: !ArchOS           -- ^ Architecture and OS
       , Platform -> PlatformWordSize
    platformWordSize                 :: !PlatformWordSize -- ^ Word size
       , Platform -> ByteOrder
    platformByteOrder                :: !ByteOrder        -- ^ Byte order (endianness)
       , Platform -> Bool
    platformUnregisterised           :: !Bool
       , Platform -> Bool
    platformHasGnuNonexecStack       :: !Bool
       , Platform -> Bool
    platformHasIdentDirective        :: !Bool
       , Platform -> Bool
    platformHasSubsectionsViaSymbols :: !Bool
          -- ^ Enable Darwin .subsections_via_symbols directive
          --
          -- See Note [Subsections Via Symbols] in GHC.CmmToAsm.X86.Ppr
       , Platform -> Bool
    platformIsCrossCompiling         :: !Bool
       , Platform -> Bool
    platformLeadingUnderscore        :: !Bool             -- ^ Symbols need underscore prefix
       , Platform -> Bool
    platformTablesNextToCode         :: !Bool
          -- ^ Determines whether we will be compiling info tables that reside just
          --   before the entry code, or with an indirection to the entry code. See
          --   TABLES_NEXT_TO_CODE in @rts/include/rts/storage/InfoTables.h@.
       , Platform -> Bool
    platformHasLibm                  :: !Bool
          -- ^ 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.

       , Platform -> Maybe PlatformConstants
    platform_constants               :: !(Maybe PlatformConstants)
          -- ^ Constants such as structure offsets, type sizes, etc.
       }
       deriving (ReadPrec [Platform]
    ReadPrec Platform
    Int -> ReadS Platform
    ReadS [Platform]
    (Int -> ReadS Platform)
    -> ReadS [Platform]
    -> ReadPrec Platform
    -> ReadPrec [Platform]
    -> Read Platform
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Platform
    readsPrec :: Int -> ReadS Platform
    $creadList :: ReadS [Platform]
    readList :: ReadS [Platform]
    $creadPrec :: ReadPrec Platform
    readPrec :: ReadPrec Platform
    $creadListPrec :: ReadPrec [Platform]
    readListPrec :: ReadPrec [Platform]
    Read, Int -> Platform -> ShowS
    [Platform] -> ShowS
    Platform -> String
    (Int -> Platform -> ShowS)
    -> (Platform -> String) -> ([Platform] -> ShowS) -> Show Platform
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Platform -> ShowS
    showsPrec :: Int -> Platform -> ShowS
    $cshow :: Platform -> String
    show :: Platform -> String
    $cshowList :: [Platform] -> ShowS
    showList :: [Platform] -> ShowS
    Show, Platform -> Platform -> Bool
    (Platform -> Platform -> Bool)
    -> (Platform -> Platform -> Bool) -> Eq Platform
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Platform -> Platform -> Bool
    == :: Platform -> Platform -> Bool
    $c/= :: Platform -> Platform -> Bool
    /= :: Platform -> Platform -> Bool
    Eq, Eq Platform
    Eq Platform =>
    (Platform -> Platform -> Ordering)
    -> (Platform -> Platform -> Bool)
    -> (Platform -> Platform -> Bool)
    -> (Platform -> Platform -> Bool)
    -> (Platform -> Platform -> Bool)
    -> (Platform -> Platform -> Platform)
    -> (Platform -> Platform -> Platform)
    -> Ord Platform
    Platform -> Platform -> Bool
    Platform -> Platform -> Ordering
    Platform -> Platform -> Platform
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Platform -> Platform -> Ordering
    compare :: Platform -> Platform -> Ordering
    $c< :: Platform -> Platform -> Bool
    < :: Platform -> Platform -> Bool
    $c<= :: Platform -> Platform -> Bool
    <= :: Platform -> Platform -> Bool
    $c> :: Platform -> Platform -> Bool
    > :: Platform -> Platform -> Bool
    $c>= :: Platform -> Platform -> Bool
    >= :: Platform -> Platform -> Bool
    $cmax :: Platform -> Platform -> Platform
    max :: Platform -> Platform -> Platform
    $cmin :: Platform -> Platform -> Platform
    min :: Platform -> Platform -> Platform
    Ord)

    wordAlignment :: Platform -> Alignment
    wordAlignment :: Platform -> Alignment
    wordAlignment Platform
    platform = Int -> Alignment
    alignmentOf (Platform -> Int
    platformWordSizeInBytes Platform
    platform)

    -- -----------------------------------------------------------------------------
    -- SSE and AVX

    -- TODO: Instead of using a separate predicate (i.e. isSse2Enabled) to
    -- check if SSE is enabled, we might have x86-64 imply the -msse2
    -- flag.

    isSseEnabled :: Platform -> Bool
    isSseEnabled :: Platform -> Bool
    isSseEnabled Platform
    platform = case Platform -> Arch
    platformArch Platform
    platform of
        Arch
    ArchX86_64 -> Bool
    True
        Arch
    ArchX86    -> Bool
    True
        Arch
    _          -> Bool
    False

    isSse2Enabled :: Platform -> Bool
    isSse2Enabled :: Platform -> Bool
    isSse2Enabled Platform
    platform = case Platform -> Arch
    platformArch Platform
    platform of
      -- We assume  SSE1 and SSE2 operations are available on both
      -- x86 and x86_64. Historically we didn't default to SSE2 and
      -- SSE1 on x86, which results in defacto nondeterminism for how
      -- rounding behaves in the associated x87 floating point instructions
      -- because variations in the spill/fpu stack placement of arguments for
      -- operations would change the precision and final result of what
      -- would otherwise be the same expressions with respect to single or
      -- double precision IEEE floating point computations.
        Arch
    ArchX86_64 -> Bool
    True
        Arch
    ArchX86    -> Bool
    True
        Arch
    _          -> Bool
    False

    -- -----------------------------------------------------------------------------
    -- Platform Constants

    platformConstants :: Platform -> PlatformConstants
    platformConstants :: Platform -> PlatformConstants
    platformConstants Platform
    platform = case Platform -> Maybe PlatformConstants
    platform_constants Platform
    platform of
      Maybe PlatformConstants
    Nothing -> String -> PlatformConstants
    forall a. HasCallStack => String -> a
    panic String
    "Platform constants not available!"
      Just PlatformConstants
    c  -> PlatformConstants
    c

    genericPlatform :: Platform
    genericPlatform :: Platform
    genericPlatform = Platform
       { platformArchOS :: ArchOS
    platformArchOS                  = Arch -> OS -> ArchOS
    ArchOS Arch
    ArchX86_64 OS
    OSLinux
       , platformWordSize :: PlatformWordSize
    platformWordSize                = PlatformWordSize
    PW8
       , platformByteOrder :: ByteOrder
    platformByteOrder               = ByteOrder
    LittleEndian
       , platformUnregisterised :: Bool
    platformUnregisterised          = Bool
    False
       , platformHasGnuNonexecStack :: Bool
    platformHasGnuNonexecStack      = Bool
    False
       , platformHasIdentDirective :: Bool
    platformHasIdentDirective       = Bool
    False
       , platformHasSubsectionsViaSymbols :: Bool
    platformHasSubsectionsViaSymbols= Bool
    False
       , platformHasLibm :: Bool
    platformHasLibm                 = Bool
    False
       , platformIsCrossCompiling :: Bool
    platformIsCrossCompiling        = Bool
    False
       , platformLeadingUnderscore :: Bool
    platformLeadingUnderscore       = Bool
    False
       , platformTablesNextToCode :: Bool
    platformTablesNextToCode        = Bool
    True
       , platform_constants :: Maybe PlatformConstants
    platform_constants               = Maybe PlatformConstants
    forall a. Maybe a
    Nothing
       }

    data PlatformWordSize
      = PW4 -- ^ A 32-bit platform
      | PW8 -- ^ A 64-bit platform
      deriving (PlatformWordSize -> PlatformWordSize -> Bool
    (PlatformWordSize -> PlatformWordSize -> Bool)
    -> (PlatformWordSize -> PlatformWordSize -> Bool)
    -> Eq PlatformWordSize
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PlatformWordSize -> PlatformWordSize -> Bool
    == :: PlatformWordSize -> PlatformWordSize -> Bool
    $c/= :: PlatformWordSize -> PlatformWordSize -> Bool
    /= :: PlatformWordSize -> PlatformWordSize -> Bool
    Eq, Eq PlatformWordSize
    Eq PlatformWordSize =>
    (PlatformWordSize -> PlatformWordSize -> Ordering)
    -> (PlatformWordSize -> PlatformWordSize -> Bool)
    -> (PlatformWordSize -> PlatformWordSize -> Bool)
    -> (PlatformWordSize -> PlatformWordSize -> Bool)
    -> (PlatformWordSize -> PlatformWordSize -> Bool)
    -> (PlatformWordSize -> PlatformWordSize -> PlatformWordSize)
    -> (PlatformWordSize -> PlatformWordSize -> PlatformWordSize)
    -> Ord PlatformWordSize
    PlatformWordSize -> PlatformWordSize -> Bool
    PlatformWordSize -> PlatformWordSize -> Ordering
    PlatformWordSize -> PlatformWordSize -> PlatformWordSize
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: PlatformWordSize -> PlatformWordSize -> Ordering
    compare :: PlatformWordSize -> PlatformWordSize -> Ordering
    $c< :: PlatformWordSize -> PlatformWordSize -> Bool
    < :: PlatformWordSize -> PlatformWordSize -> Bool
    $c<= :: PlatformWordSize -> PlatformWordSize -> Bool
    <= :: PlatformWordSize -> PlatformWordSize -> Bool
    $c> :: PlatformWordSize -> PlatformWordSize -> Bool
    > :: PlatformWordSize -> PlatformWordSize -> Bool
    $c>= :: PlatformWordSize -> PlatformWordSize -> Bool
    >= :: PlatformWordSize -> PlatformWordSize -> Bool
    $cmax :: PlatformWordSize -> PlatformWordSize -> PlatformWordSize
    max :: PlatformWordSize -> PlatformWordSize -> PlatformWordSize
    $cmin :: PlatformWordSize -> PlatformWordSize -> PlatformWordSize
    min :: PlatformWordSize -> PlatformWordSize -> PlatformWordSize
    Ord)

    instance Show PlatformWordSize where
      show :: PlatformWordSize -> String
    show PlatformWordSize
    PW4 = String
    "4"
      show PlatformWordSize
    PW8 = String
    "8"

    instance Read PlatformWordSize where
      readPrec :: ReadPrec PlatformWordSize
    readPrec = do
        i :: Int <- ReadPrec Int
    forall a. Read a => ReadPrec a
    readPrec
        case i of
          Int
    4 -> PlatformWordSize -> ReadPrec PlatformWordSize
    forall a. a -> ReadPrec a
    forall (m :: * -> *) a. Monad m => a -> m a
    return PlatformWordSize
    PW4
          Int
    8 -> PlatformWordSize -> ReadPrec PlatformWordSize
    forall a. a -> ReadPrec a
    forall (m :: * -> *) a. Monad m => a -> m a
    return PlatformWordSize
    PW8
          Int
    other -> String -> ReadPrec PlatformWordSize
    forall a. String -> ReadPrec a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail (String
    "Invalid PlatformWordSize: " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    other)

    platformWordSizeInBytes :: Platform -> Int
    platformWordSizeInBytes :: Platform -> Int
    platformWordSizeInBytes Platform
    p =
        case Platform -> PlatformWordSize
    platformWordSize Platform
    p of
          PlatformWordSize
    PW4 -> Int
    4
          PlatformWordSize
    PW8 -> Int
    8

    platformWordSizeInBits :: Platform -> Int
    platformWordSizeInBits :: Platform -> Int
    platformWordSizeInBits Platform
    p = Platform -> Int
    platformWordSizeInBytes Platform
    p Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * Int
    8

    -- | Platform architecture
    platformArch :: Platform -> Arch
    platformArch :: Platform -> Arch
    platformArch Platform
    platform = case Platform -> ArchOS
    platformArchOS Platform
    platform of
       ArchOS Arch
    arch OS
    _ -> Arch
    arch

    -- | Platform OS
    platformOS :: Platform -> OS
    platformOS :: Platform -> OS
    platformOS Platform
    platform = case Platform -> ArchOS
    platformArchOS Platform
    platform of
       ArchOS Arch
    _ OS
    os -> OS
    os

    -- | This predicate tells us whether the platform is 32-bit.
    target32Bit :: Platform -> Bool
    target32Bit :: Platform -> Bool
    target32Bit Platform
    p =
        case Platform -> PlatformWordSize
    platformWordSize Platform
    p of
          PlatformWordSize
    PW4 -> Bool
    True
          PlatformWordSize
    PW8 -> Bool
    False

    osUsesFrameworks :: OS -> Bool
    osUsesFrameworks :: OS -> Bool
    osUsesFrameworks OS
    OSDarwin = Bool
    True
    osUsesFrameworks OS
    _        = Bool
    False

    platformUsesFrameworks :: Platform -> Bool
    platformUsesFrameworks :: Platform -> Bool
    platformUsesFrameworks = OS -> Bool
    osUsesFrameworks (OS -> Bool) -> (Platform -> OS) -> Platform -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Platform -> OS
    platformOS

    osSubsectionsViaSymbols :: OS -> Bool
    osSubsectionsViaSymbols :: OS -> Bool
    osSubsectionsViaSymbols OS
    OSDarwin = Bool
    True
    osSubsectionsViaSymbols OS
    _        = Bool
    False

    -- | Minimum representable Int value for the given platform
    platformMinInt :: Platform -> Integer
    platformMinInt :: Platform -> Integer
    platformMinInt Platform
    p = case Platform -> PlatformWordSize
    platformWordSize Platform
    p of
       PlatformWordSize
    PW4 -> Int32 -> Integer
    forall a. Integral a => a -> Integer
    toInteger (Int32
    forall a. Bounded a => a
    minBound :: Int32)
       PlatformWordSize
    PW8 -> Int64 -> Integer
    forall a. Integral a => a -> Integer
    toInteger (Int64
    forall a. Bounded a => a
    minBound :: Int64)

    -- | Maximum representable Int value for the given platform
    platformMaxInt :: Platform -> Integer
    platformMaxInt :: Platform -> Integer
    platformMaxInt Platform
    p = case Platform -> PlatformWordSize
    platformWordSize Platform
    p of
       PlatformWordSize
    PW4 -> Int32 -> Integer
    forall a. Integral a => a -> Integer
    toInteger (Int32
    forall a. Bounded a => a
    maxBound :: Int32)
       PlatformWordSize
    PW8 -> Int64 -> Integer
    forall a. Integral a => a -> Integer
    toInteger (Int64
    forall a. Bounded a => a
    maxBound :: Int64)

    -- | Maximum representable Word value for the given platform
    platformMaxWord :: Platform -> Integer
    platformMaxWord :: Platform -> Integer
    platformMaxWord Platform
    p = case Platform -> PlatformWordSize
    platformWordSize Platform
    p of
       PlatformWordSize
    PW4 -> Word32 -> Integer
    forall a. Integral a => a -> Integer
    toInteger (Word32
    forall a. Bounded a => a
    maxBound :: Word32)
       PlatformWordSize
    PW8 -> Word64 -> Integer
    forall a. Integral a => a -> Integer
    toInteger (Word64
    forall a. Bounded a => a
    maxBound :: Word64)

    -- | Test if the given Integer is representable with a platform Int
    platformInIntRange :: Platform -> Integer -> Bool
    platformInIntRange :: Platform -> Integer -> Bool
    platformInIntRange Platform
    platform Integer
    x = Integer
    x Integer -> Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Platform -> Integer
    platformMinInt Platform
    platform Bool -> Bool -> Bool
    && Integer
    x Integer -> Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Platform -> Integer
    platformMaxInt Platform
    platform

    -- | Test if the given Integer is representable with a platform Word
    platformInWordRange :: Platform -> Integer -> Bool
    platformInWordRange :: Platform -> Integer -> Bool
    platformInWordRange Platform
    platform Integer
    x = Integer
    x Integer -> Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Integer
    0 Bool -> Bool -> Bool
    && Integer
    x Integer -> Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Platform -> Integer
    platformMaxWord Platform
    platform

    -- | For some architectures the C calling convention is that any
    -- integer shorter than 64 bits is replaced by its 64 bits
    -- representation using sign or zero extension.
    platformCConvNeedsExtension :: Platform -> Bool
    platformCConvNeedsExtension :: Platform -> Bool
    platformCConvNeedsExtension Platform
    platform = case Platform -> Arch
    platformArch Platform
    platform of
      ArchPPC_64 PPC_64ABI
    _ -> Bool
    True
      Arch
    ArchS390X    -> Bool
    True
      Arch
    ArchRISCV64  -> Bool
    True
      Arch
    ArchLoongArch64 -> Bool
    True
      Arch
    ArchAArch64
          -- Apple's AArch64 ABI requires that the caller sign-extend
          -- small integer arguments. See
          -- https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms
        | OS
    OSDarwin <- Platform -> OS
    platformOS Platform
    platform -> Bool
    True
      Arch
    _            -> Bool
    False

    -- | Does this platform have an RTS linker?
    platformHasRTSLinker :: Platform -> Bool
    -- Note that we've inlined this logic in hadrian's
    -- Settings.Builders.RunTest.inTreeCompilerArgs.
    -- If you change this, be sure to change it too
    platformHasRTSLinker :: Platform -> Bool
    platformHasRTSLinker Platform
    p = case ArchOS -> Arch
    archOS_arch (Platform -> ArchOS
    platformArchOS Platform
    p) of
      Arch
    ArchPPC           -> Bool
    False -- powerpc
      ArchPPC_64 PPC_64ABI
    ELF_V1 -> Bool
    False -- powerpc64
      ArchPPC_64 PPC_64ABI
    ELF_V2 -> Bool
    False -- powerpc64le
      Arch
    ArchS390X         -> Bool
    False
      Arch
    ArchLoongArch64   -> Bool
    False
      Arch
    ArchJavaScript    -> Bool
    False
      Arch
    _                 -> Bool
    True

    --------------------------------------------------
    -- Instruction sets
    --------------------------------------------------

    -- | x86 SSE instructions
    data SseVersion
       = SSE1
       | SSE2
       | SSE3
       | SSE4
       | SSE42
       deriving (SseVersion -> SseVersion -> Bool
    (SseVersion -> SseVersion -> Bool)
    -> (SseVersion -> SseVersion -> Bool) -> Eq SseVersion
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SseVersion -> SseVersion -> Bool
    == :: SseVersion -> SseVersion -> Bool
    $c/= :: SseVersion -> SseVersion -> Bool
    /= :: SseVersion -> SseVersion -> Bool
    Eq, Eq SseVersion
    Eq SseVersion =>
    (SseVersion -> SseVersion -> Ordering)
    -> (SseVersion -> SseVersion -> Bool)
    -> (SseVersion -> SseVersion -> Bool)
    -> (SseVersion -> SseVersion -> Bool)
    -> (SseVersion -> SseVersion -> Bool)
    -> (SseVersion -> SseVersion -> SseVersion)
    -> (SseVersion -> SseVersion -> SseVersion)
    -> Ord SseVersion
    SseVersion -> SseVersion -> Bool
    SseVersion -> SseVersion -> Ordering
    SseVersion -> SseVersion -> SseVersion
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: SseVersion -> SseVersion -> Ordering
    compare :: SseVersion -> SseVersion -> Ordering
    $c< :: SseVersion -> SseVersion -> Bool
    < :: SseVersion -> SseVersion -> Bool
    $c<= :: SseVersion -> SseVersion -> Bool
    <= :: SseVersion -> SseVersion -> Bool
    $c> :: SseVersion -> SseVersion -> Bool
    > :: SseVersion -> SseVersion -> Bool
    $c>= :: SseVersion -> SseVersion -> Bool
    >= :: SseVersion -> SseVersion -> Bool
    $cmax :: SseVersion -> SseVersion -> SseVersion
    max :: SseVersion -> SseVersion -> SseVersion
    $cmin :: SseVersion -> SseVersion -> SseVersion
    min :: SseVersion -> SseVersion -> SseVersion
    Ord)

    -- | x86 BMI (bit manipulation) instructions
    data BmiVersion
       = BMI1
       | BMI2
       deriving (BmiVersion -> BmiVersion -> Bool
    (BmiVersion -> BmiVersion -> Bool)
    -> (BmiVersion -> BmiVersion -> Bool) -> Eq BmiVersion
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BmiVersion -> BmiVersion -> Bool
    == :: BmiVersion -> BmiVersion -> Bool
    $c/= :: BmiVersion -> BmiVersion -> Bool
    /= :: BmiVersion -> BmiVersion -> Bool
    Eq, Eq BmiVersion
    Eq BmiVersion =>
    (BmiVersion -> BmiVersion -> Ordering)
    -> (BmiVersion -> BmiVersion -> Bool)
    -> (BmiVersion -> BmiVersion -> Bool)
    -> (BmiVersion -> BmiVersion -> Bool)
    -> (BmiVersion -> BmiVersion -> Bool)
    -> (BmiVersion -> BmiVersion -> BmiVersion)
    -> (BmiVersion -> BmiVersion -> BmiVersion)
    -> Ord BmiVersion
    BmiVersion -> BmiVersion -> Bool
    BmiVersion -> BmiVersion -> Ordering
    BmiVersion -> BmiVersion -> BmiVersion
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: BmiVersion -> BmiVersion -> Ordering
    compare :: BmiVersion -> BmiVersion -> Ordering
    $c< :: BmiVersion -> BmiVersion -> Bool
    < :: BmiVersion -> BmiVersion -> Bool
    $c<= :: BmiVersion -> BmiVersion -> Bool
    <= :: BmiVersion -> BmiVersion -> Bool
    $c> :: BmiVersion -> BmiVersion -> Bool
    > :: BmiVersion -> BmiVersion -> Bool
    $c>= :: BmiVersion -> BmiVersion -> Bool
    >= :: BmiVersion -> BmiVersion -> Bool
    $cmax :: BmiVersion -> BmiVersion -> BmiVersion
    max :: BmiVersion -> BmiVersion -> BmiVersion
    $cmin :: BmiVersion -> BmiVersion -> BmiVersion
    min :: BmiVersion -> BmiVersion -> BmiVersion
    Ord)

    -- | Platform-specific settings formerly hard-coded in Config.hs.
    --
    -- These should probably be all be triaged whether they can be computed from
    -- other settings or belong in another another place (like 'Platform' above).
    data PlatformMisc = PlatformMisc
      { -- TODO Recalculate string from richer info?
        PlatformMisc -> String
    platformMisc_targetPlatformString :: String
      , PlatformMisc -> Bool
    platformMisc_ghcWithInterpreter   :: Bool
      , PlatformMisc -> Bool
    platformMisc_libFFI               :: Bool
      , PlatformMisc -> String
    platformMisc_llvmTarget           :: String
      , PlatformMisc -> Bool
    platformMisc_targetRTSLinkerOnlySupportsSharedLibs :: Bool
      }

    platformSOName :: Platform -> FilePath -> FilePath
    platformSOName :: Platform -> ShowS
    platformSOName Platform
    platform String
    root = case Platform -> OS
    platformOS Platform
    platform of
       OS
    OSMinGW32 ->           String
    root  String -> ShowS
    <.> Platform -> String
    platformSOExt Platform
    platform
       OS
    _         -> (String
    "lib" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    root) String -> ShowS
    <.> Platform -> String
    platformSOExt Platform
    platform

    platformHsSOName :: Platform -> FilePath -> FilePath
    platformHsSOName :: Platform -> ShowS
    platformHsSOName Platform
    platform String
    root = (String
    "lib" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    root) String -> ShowS
    <.> Platform -> String
    platformSOExt Platform
    platform

    platformSOExt :: Platform -> FilePath
    platformSOExt :: Platform -> String
    platformSOExt Platform
    platform
        = case Platform -> OS
    platformOS Platform
    platform of
          OS
    OSDarwin  -> String
    "dylib"
          OS
    OSMinGW32 -> String
    "dll"
          OS
    _         -> String
    "so"

    -- Note [Platform constants]
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~
    --
    -- The RTS is partly written in C, hence we use an external C compiler to build
    -- it. Thus GHC must somehow retrieve some information about the produced code
    -- (sizes of types, offsets of struct fields, etc.) to produce compatible code.
    --
    -- This is the role of utils/deriveConstants utility: it produces a C
    -- source, compiles it with the same toolchain that will be used to build the
    -- RTS, and finally retrieves the constants from the built artefact. We can't
    -- directly run the produced program because we may be cross-compiling.
    --
    -- These constants are then stored in GhclibDerivedConstants.h header file that is
    -- bundled with the RTS unit. This file is directly imported by Cmm codes and it
    -- is also read by GHC. deriveConstants also produces the Haskell definition of
    -- the PlatformConstants datatype and the Haskell parser for the
    -- GhclibDerivedConstants.h file.
    --
    -- For quite some time, constants used by GHC were globally installed in
    -- ${libdir}/platformConstants but now GHC reads the GhclibDerivedConstants.h header
    -- bundled with the RTS unit. GHC detects when it builds the RTS unit itself and
    -- in this case it loads the header from the include-dirs passed on the
    -- command-line.
    --
    -- Note that GHC doesn't parse every "#define SOME_CONSTANT 123" individually.
    -- Instead there is a single #define that contains all the constants useful to
    -- GHC in a comma separated list:
    --
    --    #define HS_CONSTANTS "123,45,..."
    --
    -- Note that GHC mustn't directly import GhclibDerivedConstants.h as these constants
    -- are only valid for a specific target platform and we want GHC to be target
    -- agnostic.
    --

    -- | Try to locate "GhclibDerivedConstants.h" file in the given dirs and to parse the
    -- PlatformConstants from it.
    --
    -- See Note [Platform constants]
    lookupPlatformConstants :: [FilePath] -> IO (Maybe PlatformConstants)
    lookupPlatformConstants :: [String] -> IO (Maybe PlatformConstants)
    lookupPlatformConstants [String]
    include_dirs = [String] -> IO (Maybe PlatformConstants)
    find_constants [String]
    include_dirs
      where
        try_parse :: String -> IO (Maybe PlatformConstants)
    try_parse String
    d = do
            let p :: String
    p = String
    d String -> ShowS
    </> String
    "GhclibDerivedConstants.h"
            String -> IO Bool
    doesFileExist String
    p IO Bool
    -> (Bool -> IO (Maybe PlatformConstants))
    -> IO (Maybe PlatformConstants)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \case
              Bool
    True  -> PlatformConstants -> Maybe PlatformConstants
    forall a. a -> Maybe a
    Just (PlatformConstants -> Maybe PlatformConstants)
    -> IO PlatformConstants -> IO (Maybe PlatformConstants)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> String -> IO PlatformConstants
    parseConstantsHeader String
    p
              Bool
    False -> Maybe PlatformConstants -> IO (Maybe PlatformConstants)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe PlatformConstants
    forall a. Maybe a
    Nothing

        find_constants :: [String] -> IO (Maybe PlatformConstants)
    find_constants []     = Maybe PlatformConstants -> IO (Maybe PlatformConstants)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe PlatformConstants
    forall a. Maybe a
    Nothing
        find_constants (String
    x:[String]
    xs) = String -> IO (Maybe PlatformConstants)
    try_parse String
    x IO (Maybe PlatformConstants)
    -> (Maybe PlatformConstants -> IO (Maybe PlatformConstants))
    -> IO (Maybe PlatformConstants)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \case
            Maybe PlatformConstants
    Nothing -> [String] -> IO (Maybe PlatformConstants)
    find_constants [String]
    xs
            Just PlatformConstants
    c  -> Maybe PlatformConstants -> IO (Maybe PlatformConstants)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (PlatformConstants -> Maybe PlatformConstants
    forall a. a -> Maybe a
    Just PlatformConstants
    c)