+      sha256 = "sha256-/6+DtdeossBJIMbjkJwL4h3eJ7rzgNCV+ifoQKOi6AQ=";

+      sha256 = "sha256-jPIhiJMOENesUnDUJeIaPatgavc6ZVSTY5NFIAxlC+k=";

+    version = "9.10.1";

+## Nix

+

+If you are looking to use nix to develop on GHC, [check out the wiki for instructions](https://gitlab.haskell.org/ghc/ghc/-/wikis/building/preparation).

+

+-- Handle PopCnt, Clz, Ctz, BRev, and BSwap that need to only convert arg and return types

+genCall (PrimTarget op@(MO_PopCnt w)) [dst] args =

+    genCallSimpleCast w op dst args

+genCall (PrimTarget op@(MO_Clz w)) [dst] args =

+    genCallSimpleCast w op dst args

+genCall (PrimTarget op@(MO_Ctz w)) [dst] args =

+    genCallSimpleCast w op dst args

+genCall (PrimTarget op@(MO_BRev w)) [dst] args =

+    genCallSimpleCast w op dst args

+genCall (PrimTarget op@(MO_BSwap w)) [dst] args =

+    genCallSimpleCast w op dst args

+

+-- Handle Pdep and Pext that (may) require using a type with a larger bit-width

+-- than the specified but width. This register width-extension is particualarly

+-- necessary for W8 and W16.

+genCall (PrimTarget op@(MO_Pdep w)) [dst] args =

+    genCallCastWithMinWidthOf W32 w op dst args

+genCall (PrimTarget op@(MO_Pext w)) [dst] args =

+    genCallCastWithMinWidthOf W32 w op dst args

+genCallSimpleCast :: Width -> CallishMachOp -> CmmFormal -> [CmmActual]

+                  -> LlvmM StmtData

+genCallSimpleCast w = genCallCastWithMinWidthOf w w

+

+-- Handle extension case that the element should be extend to a larger bit-width

+-- for the operation and subsequently truncated, of the form:

+--   extend arg >>= \a -> call(a) >>= truncate

+genCallCastWithMinWidthOf :: Width -> Width -> CallishMachOp -> CmmFormal

+                          -> [CmmActual] -> LlvmM StmtData

+genCallCastWithMinWidthOf minW specW op dst args = do

+    let width   = widthToLlvmInt $ max minW specW

+        argsW   = const width <$> args

+        dstType = cmmToLlvmType $ localRegType dst

+        signage = cmmPrimOpRetValSignage op

+

+    fname                 <- cmmPrimOpFunctions op

+    (fptr, _, top3)       <- getInstrinct fname width argsW

+    (dstV, _dst_ty)       <- getCmmReg (CmmLocal dst)

+    let (_, arg_hints)     = foreignTargetHints $ PrimTarget op

+    let args_hints         = zip args arg_hints

+    (argsV, stmts2, top2) <- arg_vars args_hints ([], nilOL, [])

+    (argsV', stmts4)      <- castVars signage $ zip argsV argsW

+    (retV, s1)            <- doExpr width $ Call StdCall fptr argsV' []

+    (retV', stmts5)       <- castVar signage retV dstType

+    let s2                 = Store retV' dstV Nothing []

+

+    let stmts = stmts2 `appOL` stmts4 `snocOL` s1 `snocOL`

+                stmts5 `snocOL` s2

+    -- If the result of a Bit-Reverse is treated as signed,

+    -- an positive input can result in an negative output, i.e.:

+    --

+    --   identity(0x03) = 0x03 = 00000011

+    --   breverse(0x03) = 0xC0 = 11000000

+    --

+    -- Now if an extension is performed after the operation to

+    -- promote a smaller bit-width value into a larger bit-width

+    -- type, it is expected that the /bit-wise/ operations will

+    -- not be treated /numerically/ as signed.

+    --

+    -- To illustrate the difference, consider how a signed extension

+    -- for the type i16 to i32 differs for out values above:

+    --   ext_zeroed(i32, breverse(0x03)) = 0x00C0 = 0000000011000000

+    --   ext_signed(i32, breverse(0x03)) = 0xFFC0 = 1111111111000000

+    --

+    -- Here we can see that the former output is the expected result

+    -- of a bit-wise operation which needs to be promoted to a larger

+    -- bit-width type. The latter output is not desirable when we must

+    -- constraining a value into a range of i16 within an i32 type.

+    --

+    -- Hence we always treat the "signage" as unsigned for Bit-Reverse!

+    MO_BRev _   -> Unsigned

+

+    -- The same reasoning applied to Bit-Reverse above applies to ther other

+    -- bit-wise operations; do not sign extend a possibly negated number!

+    MO_BSwap  _ -> Unsigned

+    MO_Clz    _ -> Unsigned

+    MO_Ctz    _ -> Unsigned

+    MO_PopCnt _ -> Unsigned

+

+    -- All other cases, default to preserving the numeric sign when extending.

+          -- Due to the down-casting and up-casting of the operand before and

+          -- after the Pdep operation, respectively, LLVM will provide a an

+          -- incorrect result after the entire operation is complete.

+          -- This is caused by the definition of hs_pdep64 in "cbits/pdep.c".

+          -- The defined C operation takes a (64-bit) 'StgWord64' as input/output.

+          -- The result will incorrectly consider upper bits when it should not

+          -- because those upper bits are outside the value's "logical range,"

+          -- despite being present in the "actual range."

+          -- The function "hs_pdep32" works correctly for the type 'StgWord'

+          -- as input/output for the logical range of "i32." Attempting to use a

+          -- smaller logical range of "i16" or "i8" will produce incorrect results.

+          -- Hence, the call is made to "hs_pdep32" and truncated afterwards.

+          --

+          -- TODO: Determine if the definition(s) of "hs_pdep8" and "hs_pdep16"

+          -- can be specialized to return the correct results when cast using

+          -- a call to 'genCallSimpleCast', removing the need for the function

+          -- 'genCallCastWithMinWidthOf'.

+          W8   -> fsLit "hs_pdep32"

+          W16  -> fsLit "hs_pdep32"

+          -- Same issue for "i16" and "i8" values as the Pdep operation above,

+          -- see that commentary for more details as to why "hs_pext32" is called

+          -- for bit-widths of 'W8' and 'W16'.

+          W8   -> fsLit "hs_pext32"

+          W16  -> fsLit "hs_pext32"

+import GHC.Rename.Splice

+            map fix_faminst . gresToAvailInfo . mapMaybe pickLevelZeroGRE

+                                    -- NB: this filters out non level 0 exports

+               checkThLocalNameNoLift (ieLWrappedUserRdrName l name)

+               checkThLocalNameNoLift (ieLWrappedUserRdrName l name)

+               checkThLocalNameNoLift (ieLWrappedUserRdrName l name)

+               checkThLocalNameNoLift (ieLWrappedUserRdrName l name)

+    lookup_ie_kids_all ie (L _loc rdr) gre =

+         -- We only choose level 0 exports when filling in part of an export list implicitly.

+         ; let kids_0 = mapMaybe pickLevelZeroGRE gres

+         ; addUsedKids (ieWrappedName rdr) kids_0

+         ; when (null kids_0) $

+         ; return kids_0 }

+

+ieLWrappedUserRdrName :: LIEWrappedName GhcPs -> Name -> LIdOccP GhcRn

+ieLWrappedUserRdrName l n = fmap (\rdr -> WithUserRdr rdr n) $ ieLWrappedName l

+

+                 ; checkThLocalNameNoLift (ieLWrappedUserRdrName n child_nm)

+        transformGREs, pickGREs, pickGREsModExp, pickLevelZeroGRE,

+import Control.Monad ( guard , (>=>) )

+greLevels :: GlobalRdrEltX info -> Set.Set ImportLevel

+-- This function also only chooses GREs which are at level zero.

+pickGREsModExp mod gres = mapMaybe (pickLevelZeroGRE >=> pickBothGRE mod) gres

+

+pickLevelZeroGRE :: GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)

+pickLevelZeroGRE gre =

+  if NormalLevel `Set.member` greLevels gre

+    then Just gre

+    else Nothing

+(See :ref:`strict-bindings`).

+

+

+.. _strict-bindings:

+

+-- Minimal reproducer for https://gitlab.haskell.org/ghc/ghc/-/issues/20645

+{-# LANGUAGE MagicHash #-}

+{-# LANGUAGE ExtendedLiterals #-}

+import GHC.Exts

+import GHC.Word

+import Numeric (showHex)

+

+opaqueInt8# :: Int8# -> Int8#

+opaqueInt8# x = x

+{-# OPAQUE opaqueInt8# #-}

+

+main :: IO ()

+main = let !x = opaqueInt8# 109#Int8

+           !y = opaqueInt8#   1#Int8

+       in putStrLn . flip showHex "" . W# $ pext8#

+              (word8ToWord# (int8ToWord8# (0#Int8 `subInt8#` x     )))

+              (word8ToWord# (int8ToWord8# (y      `subInt8#` 4#Int8)))

+49

+test('T20645', [normal, normalise_errmsg_fun(ignore_llvm_and_vortex), when(have_llvm(), extra_ways(["optllvm"]))], compile_and_run, [''])

+import Data.Bits (Bits((.&.), bit))

+  , testPrimop "byteSwap16#" (16 `LowerBitsAreDefined` Primop.byteSwap16#) (16 `LowerBitsAreDefined` Wrapper.byteSwap16#)

+  , testPrimop "byteSwap32#" (32 `LowerBitsAreDefined` Primop.byteSwap32#) (32 `LowerBitsAreDefined` Wrapper.byteSwap32#)

+-- | A special data-type for representing functions where,

+-- since only some number of the lower bits are defined,

+-- testing for strict equality in the undefined upper bits is not appropriate!

+-- Without using this data-type, false-positive failures will be reported

+-- when the undefined bit regions do not match, even though the equality of bits

+-- in this undefined region has no bearing on correctness.

+data LowerBitsAreDefined =

+    LowerBitsAreDefined

+    { definedLowerWidth :: Word

+    -- ^ The (strictly-non-negative) number of least-significant bits

+    -- for which the attached function is defined.

+    , undefinedBehavior :: (Word# -> Word#)

+    -- ^ Function with undefined behavior for some of its most significant bits.

+    }

+

+instance TestPrimop LowerBitsAreDefined where

+  testPrimop s l r = Property s $ \ (uWord#-> x0) ->

+    let -- Create a mask to unset all bits in the undefined area,

+        -- leaving set bits only in the area of defined behavior.

+        -- Since the upper bits are undefined,

+        -- if the function defines behavior for the lower N bits,

+        -- then /only/ the lower N bits are preserved,

+        -- and the upper WORDSIZE - N bits are discarded.

+        mask = bit (fromEnum (definedLowerWidth r)) - 1

+        valL = wWord# (undefinedBehavior l x0) .&. mask

+        valR = wWord# (undefinedBehavior r x0) .&. mask

+    in  valL === valR

+

+{-# LANGUAGE ExplicitLevelImports #-}

+module DodgyLevelExport ( T(..) ) where

+

+import quote DodgyLevelExportA

+import DodgyLevelExportA (T)

+DodgyLevelExport.hs:2:27: warning: [GHC-75356] [-Wdodgy-exports (in -Wextra)]

+    The export item ‘T(..)’ suggests that

+    ‘T’ has (in-scope) constructors or record fields, but it has none

+

+module DodgyLevelExportA where

+

+data T = T { a :: Int }

+{-# LANGUAGE ExplicitLevelImports #-}

+module LevelImportExports ( module LevelImportExportsA, T(..) ) where

+

+import quote LevelImportExportsA

+import splice LevelImportExportsA

+import LevelImportExportsA(a, T)

+[1 of 2] Compiling LevelImportExportsA ( LevelImportExportsA.hs, LevelImportExportsA.o )

+[2 of 2] Compiling LevelImportExports ( LevelImportExports.hs, LevelImportExports.o )

+exports:

+  LevelImportExportsA.a

+  LevelImportExportsA.T

+defaults:

+module LevelImportExportsA where

+

+a = 100

+b = 100

+

+data T = T { c :: Int }

+LevelImportExports:

+	"$(TEST_HC)" $(TEST_HC_OPTS) -haddock LevelImportExports.hs

+	"$(TEST_HC)" --show-iface LevelImportExports.hi | grep -A3 "^exports:"

+

+module ModuleExport where

+

+-- Should fail

+import ModuleExportA (a)

+ModuleExport.hs:4:23: error: [GHC-61689]

+    Module ‘ModuleExportA’ does not export ‘a’.

+

+{-# LANGUAGE ExplicitLevelImports #-}

+-- Module export only exports level 0 things (b)

+module ModuleExportA (module ModuleExportB) where

+

+-- Everything at level 1

+import quote ModuleExportB

+-- Only b at level 0

+import ModuleExportB (b)

+module ModuleExportB where

+

+a = ()

+b = ()

+

+

+{-# LANGUAGE ExplicitLevelImports, TemplateHaskell #-}

+module T26090 ( a --varaible

+              , T(..) -- WithAll

+              , S(s) -- With

+              , R    -- Abs

+              ) where

+

+import quote T26090A

+import T26090A (T(T), S)

+

+T26090.hs:2:17: error: [GHC-28914]

+    • Level error: ‘a’ is bound at level 1 but used at level 0

+    • Available from the imports:

+      • imported from ‘T26090A’ at 1 at T26090.hs:8:1-20

+

+T26090.hs:4:17: error: [GHC-28914]

+    • Level error: ‘s’ is bound at level 1 but used at level 0

+    • Available from the imports:

+      • imported from ‘T26090A’ at 1 at T26090.hs:8:1-20

+    • In the export: S(s)

+

+T26090.hs:5:17: error: [GHC-28914]

+    • Level error: ‘R’ is bound at level 1 but used at level 0

+    • Available from the imports:

+      • imported from ‘T26090A’ at 1 at T26090.hs:8:1-20

+

+{-# LANGUAGE ExplicitLevelImports, TemplateHaskell #-}

+module T26090A where

+

+import Language.Haskell.TH

+

+a :: Q Exp

+a = [| True |]

+

+data T = T { t :: () }

+

+data S = S { s :: () }

+

+data R = R { r :: () }

+

+test('T26090', [], multimod_compile_fail, ['T26090', '-v0'])

+test('ModuleExport', [], multimod_compile_fail, ['ModuleExport', '-v0'])

+test('LevelImportExports', [], makefile_test, [])

+test('DodgyLevelExport', [], multimod_compile, ['DodgyLevelExport', '-v0 -Wdodgy-exports'])