, ncgThisModule            :: !Module          -- ^ The name of the module we are currently compiling

    , ncgProcAlignment         :: !(Maybe Int)     -- ^ Mandatory proc alignment

    , ncgExternalDynamicRefs   :: !Bool            -- ^ Generate code to link against dynamic libraries

    , ncgPIC                   :: !Bool            -- ^ Enable Position-Independent Code

    , ncgInlineThresholdMemcpy :: !Word            -- ^ If inlining `memcpy` produces less than this threshold (in pseudo-instruction unit), do it

    , ncgInlineThresholdMemset :: !Word            -- ^ Ditto for `memset`

   if platformOS platform == OSMinGW32

      && platformTablesNextToCode platform

      && externallyVisibleCLabel lbl

      then let

         asData = isCmmData || isInfoTableLabel lbl

         in

    , ncgAsmContext            = initSDocContext dflags PprCode

    , ncgProcAlignment         = cmmProcAlignment dflags

    , ncgExternalDynamicRefs   = gopt Opt_ExternalDynamicRefs dflags

    , ncgPIC                   = positionIndependent dflags

    , ncgInlineThresholdMemcpy = fromIntegral $ maxInlineMemcpyInsns dflags

    , ncgInlineThresholdMemset = fromIntegral $ maxInlineMemsetInsns dflags

 import Control.Concurrent.QSem

 import Control.Concurrent.QSemN

 {- $conc_intro

 The concurrency extension for Haskell is described in the paper

 #include "Rts.h"

 void init_ghc_hs_iface(void);

 // Forward declarations

     return what;

 }

 int get_unique_file_info_hwnd(HANDLE h, HsWord64 *dev, HsWord64 *ino)

 {

     BY_HANDLE_FILE_INFORMATION info;

 }

 /* If true then caller needs to free tempFileName.  */

 bool __createUUIDTempFileErrNo (wchar_t* pathName, wchar_t* prefix,

                                 wchar_t* suffix, wchar_t** tempFileName)

 {

  *   1 => Input ready, 0 => not ready, -1 => error

  * On error, sets `errno`.

  */

 int

 fdReady(int fd, bool write, int64_t msecs, bool isSock)

 {

 #if defined(_WIN32)

 /* in Win32Utils.c */

 extern HsWord64 getMonotonicUSec(void);

 #endif

                  -> IO ()

 -- mp_bitcnt_t mpn_popcount (const mp_limb_t *s1p, mp_size_t n)

 foreign import ccall unsafe "gmp.h __gmpn_popcount"

 -- double integer_gmp_mpn_get_d (const mp_limb_t sp[], const mp_size_t sn)

 foreign import ccall unsafe "integer_gmp_mpn_get_d"

 powerDouble :: Double -> Double -> Double

 powerDouble  (D# x) (D# y) = D# (x **## y)

 ------------------------------------------------------------------------

 -- Coercion rules

 foreign import ccall unsafe "rintDouble"

     c_rintDouble :: Double -> Double

 foreign import ccall unsafe "rintFloat"

 import GHC.Internal.Base ( String, otherwise, return, ($) )

 import GHC.Internal.Types ( Bool(..) )

 -- "errno" type

 -- ------------

 foreign import ccall safe "__get_console_echo"

     c_get_console_echo :: HANDLE -> IO BOOL

 foreign import ccall safe "__close_handle"

 foreign import ccall safe "__handle_type"

 foreign import ccall safe "__set_file_pointer"

   c_set_file_pointer :: HANDLE -> CLong -> DWORD -> Ptr CLong -> IO BOOL

        | hasFlag (#{const GENERIC_WRITE})                           -> return WriteMode

        | otherwise -> error "unknown access mask in handleToMode."

 foreign import ccall unsafe "__get_handle_access_mask"

 release :: RawHandle a => a -> IO ()

 release h = if isLockable h

 -- | Returns -1 on error. Otherwise writes two values representing

 -- the file into the given ptrs.

 foreign import ccall unsafe "get_unique_file_info_hwnd"

 -- | getUniqueFileInfo assumes the C call to getUniqueFileInfo

 -- succeeds.

 getUniqueFileInfo :: RawHandle a => a -> IO (Word64, Word64)

 getUniqueFileInfo handle = do

   with 0 $ \devptr -> do

 foreign import ccall "getTempFileNameErrorNo" c_getTempFileNameErrorNo

   :: CWString -> CWString -> CWString -> CUInt -> Ptr CWchar -> IO Bool

   :: CWString -> CWString -> CWString -> Ptr CWString -> IO Bool

 pathSeparator :: String -> Bool

 foreign import capi unsafe "HsBase.h _utime"

    c_utime :: CString -> Ptr CUtimbuf -> IO CInt

 foreign import capi unsafe "HsBase.h _getpid"

 #else

 -- We use CAPI as on some OSs (eg. Linux) this is wrapped by a macro

 -- which redirects to the 64-bit-off_t versions when large file

 c_getpid :: IO CPid

 c_getpid = pure 1

 #else

 foreign import ccall unsafe "HsBase.h getpid"

 #endif

 #endif

 foreign import ccall unsafe "HsBase.h __hscore_o_rdwr"   o_RDWR   :: CInt

 foreign import ccall unsafe "HsBase.h __hscore_o_append" o_APPEND :: CInt

 foreign import ccall unsafe "HsBase.h __hscore_o_creat"  o_CREAT  :: CInt

 foreign import ccall unsafe "HsBase.h __hscore_o_trunc"  o_TRUNC  :: CInt

 -- non-POSIX flags.

 -- by @GetLastError@.

 -- | Map the last system error to an errno value, and assign it to @errno@.

 foreign import ccall unsafe "maperrno"             -- in Win32Utils.c

 -- | Pure function variant of 'c_maperrno' that does not call @GetLastError@

 -- or modify @errno@.

 foreign import ccall unsafe "maperrno_func"        -- in Win32Utils.c

 foreign import ccall unsafe "base_getErrorMessage" -- in Win32Utils.c

     c_getErrorMessage :: DWORD -> IO LPWSTR