From a4f64b30b054b168a8affd5f246df338172a4da6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ludovic=20Court=C3=A8s?= Date: Sun, 18 Aug 2024 22:24:36 +0200 Subject: [PATCH] gnu: ghc-basement: Fix compilation on 32-bit platforms. * gnu/packages/patches/ghc-basement-fix-32-bit.patch: New file. * gnu/local.mk (dist_patch_DATA): Add it. * gnu/packages/haskell-xyz.scm (ghc-basement)[arguments]: New field. Change-Id: I4d462754cad3daf8328e7d3c95c184a9e12a45cd --- gnu/local.mk | 1 + gnu/packages/haskell-xyz.scm | 12 + .../patches/ghc-basement-fix-32-bit.patch | 226 ++++++++++++++++++ 3 files changed, 239 insertions(+) create mode 100644 gnu/packages/patches/ghc-basement-fix-32-bit.patch diff --git a/gnu/local.mk b/gnu/local.mk index d31a31884a..aba33c131d 100644 --- a/gnu/local.mk +++ b/gnu/local.mk @@ -1370,6 +1370,7 @@ dist_patch_DATA = \ %D%/packages/patches/ghc-9.2-cabal-support-package-path.patch \ %D%/packages/patches/ghc-9-StgCRunAsm-only-when-needed.patch \ %D%/packages/patches/ghc-9.2-grep-warnings.patch \ + %D%/packages/patches/ghc-basement-fix-32-bit.patch \ %D%/packages/patches/ghc-testsuite-dlopen-pie.patch \ %D%/packages/patches/ghc-testsuite-grep-compat.patch \ %D%/packages/patches/ghc-testsuite-recomp015-execstack.patch \ diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm index 197a556f77..62b7268255 100644 --- a/gnu/packages/haskell-xyz.scm +++ b/gnu/packages/haskell-xyz.scm @@ -800,6 +800,18 @@ (define-public ghc-basement (sha256 (base32 "00332i4n98gh06x8ii4p8mhjpq0ch1bdan9hxmdblxpgk8j7xdvz")))) (build-system haskell-build-system) + (arguments + (if (target-64bit?) + '() + (list #:phases + #~(modify-phases %standard-phases + (add-after 'unpack 'patch-for-32-bit-system + (lambda _ + (define patch + #$(local-file + (search-patch "ghc-basement-fix-32-bit.patch"))) + + (invoke "patch" "-p1" "--force" "-i" patch))))))) (properties '((upstream-name . "basement"))) (home-page "https://github.com/haskell-foundation/foundation#readme") (synopsis "Basic primitives for Foundation starter pack") diff --git a/gnu/packages/patches/ghc-basement-fix-32-bit.patch b/gnu/packages/patches/ghc-basement-fix-32-bit.patch new file mode 100644 index 0000000000..0a9f78bdd4 --- /dev/null +++ b/gnu/packages/patches/ghc-basement-fix-32-bit.patch @@ -0,0 +1,226 @@ +Fix compilation of ghc-basement with newer GHC on 32-bit platforms. + +Patch taken from: + + https://github.com/NixOS/nixpkgs/blob/83f6c2617c662c541763ab20e0210ed02686137c/pkgs/development/haskell-modules/patches/basement-fix-32-bit.patch + +Upstream issue: + + https://github.com/haskell-foundation/foundation/pull/573 + +--- a/Basement/Bits.hs ++++ b/Basement/Bits.hs +@@ -54,8 +54,12 @@ + import Basement.Compat.Primitive + + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 902 ++import GHC.Exts ++#else + import GHC.IntWord64 + #endif ++#endif + + -- | operation over finite bits + class FiniteBitsOps bits where +--- a/Basement/From.hs ++++ b/Basement/From.hs +@@ -272,23 +272,11 @@ + tryFrom = BlockN.toBlockN . UArray.toBlock . BoxArray.mapToUnboxed id + + instance (KnownNat n, NatWithinBound Word8 n) => From (Zn64 n) Word8 where +-#if __GLASGOW_HASKELL__ >= 904 +- from = narrow . unZn64 where narrow (W64# w) = W8# (wordToWord8# (word64ToWord# (GHC.Prim.word64ToWord# w))) +-#else + from = narrow . unZn64 where narrow (W64# w) = W8# (wordToWord8# (word64ToWord# w)) +-#endif + instance (KnownNat n, NatWithinBound Word16 n) => From (Zn64 n) Word16 where +-#if __GLASGOW_HASKELL__ >= 904 +- from = narrow . unZn64 where narrow (W64# w) = W16# (wordToWord16# (word64ToWord# (GHC.Prim.word64ToWord# w))) +-#else + from = narrow . unZn64 where narrow (W64# w) = W16# (wordToWord16# (word64ToWord# w)) +-#endif + instance (KnownNat n, NatWithinBound Word32 n) => From (Zn64 n) Word32 where +-#if __GLASGOW_HASKELL__ >= 904 +- from = narrow . unZn64 where narrow (W64# w) = W32# (wordToWord32# (word64ToWord# (GHC.Prim.word64ToWord# w))) +-#else + from = narrow . unZn64 where narrow (W64# w) = W32# (wordToWord32# (word64ToWord# w)) +-#endif + instance From (Zn64 n) Word64 where + from = unZn64 + instance From (Zn64 n) Word128 where +@@ -297,23 +285,11 @@ + from = from . unZn64 + + instance (KnownNat n, NatWithinBound Word8 n) => From (Zn n) Word8 where +-#if __GLASGOW_HASKELL__ >= 904 +- from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W8# (wordToWord8# (word64ToWord# (GHC.Prim.word64ToWord# w))) +-#else + from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W8# (wordToWord8# (word64ToWord# w)) +-#endif + instance (KnownNat n, NatWithinBound Word16 n) => From (Zn n) Word16 where +-#if __GLASGOW_HASKELL__ >= 904 +- from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W16# (wordToWord16# (word64ToWord# (GHC.Prim.word64ToWord# w))) +-#else + from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W16# (wordToWord16# (word64ToWord# w)) +-#endif + instance (KnownNat n, NatWithinBound Word32 n) => From (Zn n) Word32 where +-#if __GLASGOW_HASKELL__ >= 904 +- from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W32# (wordToWord32# (word64ToWord# (GHC.Prim.word64ToWord# w))) +-#else + from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W32# (wordToWord32# (word64ToWord# w)) +-#endif + instance (KnownNat n, NatWithinBound Word64 n) => From (Zn n) Word64 where + from = naturalToWord64 . unZn + instance (KnownNat n, NatWithinBound Word128 n) => From (Zn n) Word128 where +--- a/Basement/Numerical/Additive.hs ++++ b/Basement/Numerical/Additive.hs +@@ -30,8 +30,12 @@ + import qualified Basement.Types.Word256 as Word256 + + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 902 ++import GHC.Exts ++#else + import GHC.IntWord64 + #endif ++#endif + + -- | Represent class of things that can be added together, + -- contains a neutral element and is commutative. +--- a/Basement/Numerical/Conversion.hs ++++ b/Basement/Numerical/Conversion.hs +@@ -26,8 +26,12 @@ + import Basement.Compat.Primitive + + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 902 ++import GHC.Exts ++#else + import GHC.IntWord64 + #endif ++#endif + + intToInt64 :: Int -> Int64 + #if WORD_SIZE_IN_BITS == 64 +@@ -96,11 +100,22 @@ + #endif + + #if WORD_SIZE_IN_BITS == 64 ++#if __GLASGOW_HASKELL__ >= 902 ++word64ToWord# :: Word64# -> Word# ++word64ToWord# i = word64ToWord# i ++#else + word64ToWord# :: Word# -> Word# + word64ToWord# i = i ++#endif + {-# INLINE word64ToWord# #-} + #endif + ++#if WORD_SIZE_IN_BITS < 64 ++word64ToWord32# :: Word64# -> Word32# ++word64ToWord32# i = wordToWord32# (word64ToWord# i) ++{-# INLINE word64ToWord32# #-} ++#endif ++ + -- | 2 Word32s + data Word32x2 = Word32x2 {-# UNPACK #-} !Word32 + {-# UNPACK #-} !Word32 +@@ -113,9 +128,14 @@ + word64ToWord32s (W64# w64) = Word32x2 (W32# (wordToWord32# (uncheckedShiftRL# w64 32#))) (W32# (wordToWord32# w64)) + #endif + #else ++#if __GLASGOW_HASKELL__ >= 902 ++word64ToWord32s :: Word64 -> Word32x2 ++word64ToWord32s (W64# w64) = Word32x2 (W32# (word64ToWord32# (uncheckedShiftRL64# w64 32#))) (W32# (word64ToWord32# w64)) ++#else + word64ToWord32s :: Word64 -> Word32x2 + word64ToWord32s (W64# w64) = Word32x2 (W32# (word64ToWord# (uncheckedShiftRL64# w64 32#))) (W32# (word64ToWord# w64)) + #endif ++#endif + + wordToChar :: Word -> Char + wordToChar (W# word) = C# (chr# (word2Int# word)) +--- a/Basement/PrimType.hs ++++ b/Basement/PrimType.hs +@@ -54,7 +54,11 @@ + import qualified Prelude (quot) + + #if WORD_SIZE_IN_BITS < 64 +-import GHC.IntWord64 ++#if __GLASGOW_HASKELL__ >= 902 ++import GHC.Exts ++#else ++import GHC.IntWord64 ++#endif + #endif + + #ifdef FOUNDATION_BOUNDS_CHECK +--- a/Basement/Types/OffsetSize.hs ++++ b/Basement/Types/OffsetSize.hs +@@ -70,8 +70,12 @@ + import qualified Prelude + + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 902 ++import GHC.Exts ++#else + import GHC.IntWord64 + #endif ++#endif + + -- | File size in bytes + newtype FileSize = FileSize Word64 +@@ -225,20 +229,26 @@ + + csizeOfSize :: CountOf Word8 -> CSize + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 902 ++csizeOfSize (CountOf (I# sz)) = CSize (W32# (wordToWord32# (int2Word# sz))) ++#else + csizeOfSize (CountOf (I# sz)) = CSize (W32# (int2Word# sz)) ++#endif + #else + #if __GLASGOW_HASKELL__ >= 904 + csizeOfSize (CountOf (I# sz)) = CSize (W64# (wordToWord64# (int2Word# sz))) +- + #else + csizeOfSize (CountOf (I# sz)) = CSize (W64# (int2Word# sz)) +- + #endif + #endif + + csizeOfOffset :: Offset8 -> CSize + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 902 ++csizeOfOffset (Offset (I# sz)) = CSize (W32# (wordToWord32# (int2Word# sz))) ++#else + csizeOfOffset (Offset (I# sz)) = CSize (W32# (int2Word# sz)) ++#endif + #else + #if __GLASGOW_HASKELL__ >= 904 + csizeOfOffset (Offset (I# sz)) = CSize (W64# (wordToWord64# (int2Word# sz))) +@@ -250,7 +260,11 @@ + sizeOfCSSize :: CSsize -> CountOf Word8 + sizeOfCSSize (CSsize (-1)) = error "invalid size: CSSize is -1" + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 902 ++sizeOfCSSize (CSsize (I32# sz)) = CountOf (I# (int32ToInt# sz)) ++#else + sizeOfCSSize (CSsize (I32# sz)) = CountOf (I# sz) ++#endif + #else + #if __GLASGOW_HASKELL__ >= 904 + sizeOfCSSize (CSsize (I64# sz)) = CountOf (I# (int64ToInt# sz)) +@@ -261,7 +275,11 @@ + + sizeOfCSize :: CSize -> CountOf Word8 + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 902 ++sizeOfCSize (CSize (W32# sz)) = CountOf (I# (word2Int# (word32ToWord# sz))) ++#else + sizeOfCSize (CSize (W32# sz)) = CountOf (I# (word2Int# sz)) ++#endif + #else + #if __GLASGOW_HASKELL__ >= 904 + sizeOfCSize (CSize (W64# sz)) = CountOf (I# (word2Int# (word64ToWord# sz)))