[CmmSized Ints] I8/I16/I32 with unpacked ints now.

(cherry picked from commit acb5ce792806bc3c1e1730c6bdae853d2755de16)

5 files changed, 153 insertions, 138 deletions

diff --git a/compiler/GHC/Builtin/primops.txt.pp b/compiler/GHC/Builtin/primops.txt.pp
index 2ee69382dc..b2f8f07c56 100644
--- a/compiler/GHC/Builtin/primops.txt.pp
+++ b/compiler/GHC/Builtin/primops.txt.pp
@@ -408,6 +408,14 @@ primop Int16LtOp "ltInt16#" Compare Int16# -> Int16# -> Int#
 primop Int16NeOp "neInt16#" Compare Int16# -> Int16# -> Int#
 
 ------------------------------------------------------------------------
+section "Int32#"
+        {Operations on 32-bit integers.}
+------------------------------------------------------------------------
+
+primop Int32Extend "extendInt32#" GenPrimOp Int32# -> Int#
+primop Int32Narrow "narrowInt32#" GenPrimOp Int# -> Int32#
+
+------------------------------------------------------------------------
 section "Word16#"
         {Operations on 16-bit unsigned integers.}
 ------------------------------------------------------------------------
diff --git a/compiler/GHC/HsToCore/Foreign/Decl.hs b/compiler/GHC/HsToCore/Foreign/Decl.hs
index 4d6abc4132..224fd23c3d 100644
--- a/compiler/GHC/HsToCore/Foreign/Decl.hs
+++ b/compiler/GHC/HsToCore/Foreign/Decl.hs
@@ -849,6 +849,8 @@ primTyDescChar platform ty
  = case typePrimRep1 (getPrimTyOf ty) of
      IntRep      -> signed_word
      WordRep     -> unsigned_word
+     Int32Rep    -> 'W'
+     Word32Rep   -> 'w'
      Int64Rep    -> 'L'
      Word64Rep   -> 'l'
      AddrRep     -> 'p'
diff --git a/compiler/GHC/StgToCmm/Prim.hs b/compiler/GHC/StgToCmm/Prim.hs
index a6f2dcb6da..b555391340 100644
--- a/compiler/GHC/StgToCmm/Prim.hs
+++ b/compiler/GHC/StgToCmm/Prim.hs
@@ -1228,6 +1228,11 @@ emitPrimOp dflags primop = case primop of
   Int16LtOp       -> \args -> opTranslate args (MO_S_Lt W16)
   Int16NeOp       -> \args -> opTranslate args (MO_Ne W16)
 
+-- Int32# signed ops
+
+  Int32Extend     -> \args -> opTranslate args (MO_SS_Conv W32 (wordWidth platform))
+  Int32Narrow     -> \args -> opTranslate args (MO_SS_Conv (wordWidth platform) W32)
+
 -- Word16# unsigned ops
 
   Word16Extend     -> \args -> opTranslate args (MO_UU_Conv W16 (wordWidth platform))
diff --git a/libraries/base/GHC/Int.hs b/libraries/base/GHC/Int.hs
index 5449a79c8f..129e33f974 100644
--- a/libraries/base/GHC/Int.hs
+++ b/libraries/base/GHC/Int.hs
@@ -59,7 +59,7 @@ import GHC.Show
 -- Int8 is represented in the same way as Int. Operations may assume
 -- and must ensure that it holds only values from its logical range.
 
-data {-# CTYPE "HsInt8" #-} Int8 = I8# Int#
+data {-# CTYPE "HsInt8" #-} Int8 = I8# Int8#
 -- ^ 8-bit signed integer type
 
 -- See GHC.Classes#matching_overloaded_methods_in_rules
@@ -69,8 +69,8 @@ instance Eq Int8 where
     (/=) = neInt8
 
 eqInt8, neInt8 :: Int8 -> Int8 -> Bool
-eqInt8 (I8# x) (I8# y) = isTrue# (x ==# y)
-neInt8 (I8# x) (I8# y) = isTrue# (x /=# y)
+eqInt8 (I8# x) (I8# y) = isTrue# ((extendInt8# x) ==# (extendInt8# y))
+neInt8 (I8# x) (I8# y) = isTrue# ((extendInt8# x) /=# (extendInt8# y))
 {-# INLINE [1] eqInt8 #-}
 {-# INLINE [1] neInt8 #-}
 
@@ -86,10 +86,10 @@ instance Ord Int8 where
 {-# INLINE [1] ltInt8 #-}
 {-# INLINE [1] leInt8 #-}
 gtInt8, geInt8, ltInt8, leInt8 :: Int8 -> Int8 -> Bool
-(I8# x) `gtInt8` (I8# y) = isTrue# (x >#  y)
-(I8# x) `geInt8` (I8# y) = isTrue# (x >=# y)
-(I8# x) `ltInt8` (I8# y) = isTrue# (x <#  y)
-(I8# x) `leInt8` (I8# y) = isTrue# (x <=# y)
+(I8# x) `gtInt8` (I8# y) = isTrue# ((extendInt8# x) >#  (extendInt8# y))
+(I8# x) `geInt8` (I8# y) = isTrue# ((extendInt8# x) >=# (extendInt8# y))
+(I8# x) `ltInt8` (I8# y) = isTrue# ((extendInt8# x) <#  (extendInt8# y))
+(I8# x) `leInt8` (I8# y) = isTrue# ((extendInt8# x) <=# (extendInt8# y))
 
 -- | @since 2.01
 instance Show Int8 where
@@ -97,16 +97,16 @@ instance Show Int8 where
 
 -- | @since 2.01
 instance Num Int8 where
-    (I8# x#) + (I8# y#)    = I8# (narrow8Int# (x# +# y#))
-    (I8# x#) - (I8# y#)    = I8# (narrow8Int# (x# -# y#))
-    (I8# x#) * (I8# y#)    = I8# (narrow8Int# (x# *# y#))
-    negate (I8# x#)        = I8# (narrow8Int# (negateInt# x#))
+    (I8# x#) + (I8# y#)    = I8# (narrowInt8# ((extendInt8# x#) +# (extendInt8# y#)))
+    (I8# x#) - (I8# y#)    = I8# (narrowInt8# ((extendInt8# x#) -# (extendInt8# y#)))
+    (I8# x#) * (I8# y#)    = I8# (narrowInt8# ((extendInt8# x#) *# (extendInt8# y#)))
+    negate (I8# x#)        = I8# (narrowInt8# (negateInt# (extendInt8# x#)))
     abs x | x >= 0         = x
           | otherwise      = negate x
     signum x | x > 0       = 1
     signum 0               = 0
     signum _               = -1
-    fromInteger i          = I8# (narrow8Int# (integerToInt# i))
+    fromInteger i          = I8# (narrowInt8# (integerToInt# i))
 
 -- | @since 2.01
 instance Real Int8 where
@@ -122,9 +122,9 @@ instance Enum Int8 where
         | otherwise     = predError "Int8"
     toEnum i@(I# i#)
         | i >= fromIntegral (minBound::Int8) && i <= fromIntegral (maxBound::Int8)
-                        = I8# i#
+                        = I8# (narrowInt8# i#)
         | otherwise     = toEnumError "Int8" i (minBound::Int8, maxBound::Int8)
-    fromEnum (I8# x#)   = I# x#
+    fromEnum (I8# x#)   = I# (extendInt8# x#)
     enumFrom            = boundedEnumFrom
     enumFromThen        = boundedEnumFromThen
 
@@ -133,34 +133,34 @@ instance Integral Int8 where
     quot    x@(I8# x#) y@(I8# y#)
         | y == 0                     = divZeroError
         | y == (-1) && x == minBound = overflowError -- Note [Order of tests]
-        | otherwise                  = I8# (narrow8Int# (x# `quotInt#` y#))
+        | otherwise                  = I8# (narrowInt8# ((extendInt8# x#) `quotInt#` (extendInt8# y#)))
     rem     (I8# x#) y@(I8# y#)
         | y == 0                     = divZeroError
-        | otherwise                  = I8# (narrow8Int# (x# `remInt#` y#))
+        | otherwise                  = I8# (narrowInt8# ((extendInt8# x#) `remInt#` (extendInt8# y#)))
     div     x@(I8# x#) y@(I8# y#)
         | y == 0                     = divZeroError
         | y == (-1) && x == minBound = overflowError -- Note [Order of tests]
-        | otherwise                  = I8# (narrow8Int# (x# `divInt#` y#))
+        | otherwise                  = I8# (narrowInt8# ((extendInt8# x#) `divInt#` (extendInt8# y#)))
     mod       (I8# x#) y@(I8# y#)
         | y == 0                     = divZeroError
-        | otherwise                  = I8# (narrow8Int# (x# `modInt#` y#))
+        | otherwise                  = I8# (narrowInt8# ((extendInt8# x#) `modInt#` (extendInt8# y#)))
     quotRem x@(I8# x#) y@(I8# y#)
         | y == 0                     = divZeroError
           -- Note [Order of tests]
         | y == (-1) && x == minBound = (overflowError, 0)
-        | otherwise                  = case x# `quotRemInt#` y# of
+        | otherwise                  = case (extendInt8# x#) `quotRemInt#` (extendInt8# y#) of
                                        (# q, r #) ->
-                                           (I8# (narrow8Int# q),
-                                            I8# (narrow8Int# r))
+                                           (I8# (narrowInt8# q),
+                                            I8# (narrowInt8# r))
     divMod  x@(I8# x#) y@(I8# y#)
         | y == 0                     = divZeroError
           -- Note [Order of tests]
         | y == (-1) && x == minBound = (overflowError, 0)
-        | otherwise                  = case x# `divModInt#` y# of
+        | otherwise                  = case (extendInt8# x#) `divModInt#` (extendInt8# y#) of
                                        (# d, m #) ->
-                                           (I8# (narrow8Int# d),
-                                            I8# (narrow8Int# m))
-    toInteger (I8# x#)               = IS x#
+                                           (I8# (narrowInt8# d),
+                                            I8# (narrowInt8# m))
+    toInteger (I8# x#)               = IS (extendInt8# x#)
 
 -- | @since 2.01
 instance Bounded Int8 where
@@ -184,34 +184,34 @@ instance Bits Int8 where
     {-# INLINE testBit #-}
     {-# INLINE popCount #-}
 
-    (I8# x#) .&.   (I8# y#)   = I8# (x# `andI#` y#)
-    (I8# x#) .|.   (I8# y#)   = I8# (x# `orI#`  y#)
-    (I8# x#) `xor` (I8# y#)   = I8# (x# `xorI#` y#)
-    complement (I8# x#)       = I8# (notI# x#)
+    (I8# x#) .&.   (I8# y#)   = I8# (narrowInt8# ((extendInt8# x#) `andI#` (extendInt8# y#)))
+    (I8# x#) .|.   (I8# y#)   = I8# (narrowInt8# ((extendInt8# x#) `orI#`  (extendInt8# y#)))
+    (I8# x#) `xor` (I8# y#)   = I8# (narrowInt8# ((extendInt8# x#) `xorI#` (extendInt8# y#)))
+    complement (I8# x#)       = I8# (narrowInt8# (notI# (extendInt8# x#)))
     (I8# x#) `shift` (I# i#)
-        | isTrue# (i# >=# 0#) = I8# (narrow8Int# (x# `iShiftL#` i#))
-        | otherwise           = I8# (x# `iShiftRA#` negateInt# i#)
+        | isTrue# (i# >=# 0#) = I8# (narrowInt8# ((extendInt8# x#) `iShiftL#` i#))
+        | otherwise           = I8# (narrowInt8# ((extendInt8# x#) `iShiftRA#` negateInt# i#))
     (I8# x#) `shiftL`       (I# i#)
-        | isTrue# (i# >=# 0#) = I8# (narrow8Int# (x# `iShiftL#` i#))
+        | isTrue# (i# >=# 0#) = I8# (narrowInt8# ((extendInt8# x#) `iShiftL#` i#))
         | otherwise           = overflowError
-    (I8# x#) `unsafeShiftL` (I# i#) = I8# (narrow8Int# (x# `uncheckedIShiftL#` i#))
+    (I8# x#) `unsafeShiftL` (I# i#) = I8# (narrowInt8# ((extendInt8# x#) `uncheckedIShiftL#` i#))
     (I8# x#) `shiftR`       (I# i#)
-        | isTrue# (i# >=# 0#) = I8# (x# `iShiftRA#` i#)
+        | isTrue# (i# >=# 0#) = I8# (narrowInt8# ((extendInt8# x#) `iShiftRA#` i#))
         | otherwise           = overflowError
-    (I8# x#) `unsafeShiftR` (I# i#) = I8# (x# `uncheckedIShiftRA#` i#)
+    (I8# x#) `unsafeShiftR` (I# i#) = I8# (narrowInt8# ((extendInt8# x#) `uncheckedIShiftRA#` i#))
     (I8# x#) `rotate` (I# i#)
         | isTrue# (i'# ==# 0#)
         = I8# x#
         | otherwise
-        = I8# (narrow8Int# (word2Int# ((x'# `uncheckedShiftL#` i'#) `or#`
+        = I8# (narrowInt8# (word2Int# ((x'# `uncheckedShiftL#` i'#) `or#`
                                        (x'# `uncheckedShiftRL#` (8# -# i'#)))))
         where
-        !x'# = narrow8Word# (int2Word# x#)
+        !x'# = narrow8Word# (int2Word# (extendInt8# x#))
         !i'# = word2Int# (int2Word# i# `and#` 7##)
     bitSizeMaybe i            = Just (finiteBitSize i)
     bitSize i                 = finiteBitSize i
     isSigned _                = True
-    popCount (I8# x#)         = I# (word2Int# (popCnt8# (int2Word# x#)))
+    popCount (I8# x#)         = I# (word2Int# (popCnt8# (int2Word# (extendInt8# x#))))
     bit                       = bitDefault
     testBit                   = testBitDefault
 
@@ -220,13 +220,13 @@ instance FiniteBits Int8 where
     {-# INLINE countLeadingZeros #-}
     {-# INLINE countTrailingZeros #-}
     finiteBitSize _ = 8
-    countLeadingZeros  (I8# x#) = I# (word2Int# (clz8# (int2Word# x#)))
-    countTrailingZeros (I8# x#) = I# (word2Int# (ctz8# (int2Word# x#)))
+    countLeadingZeros  (I8# x#) = I# (word2Int# (clz8# (int2Word# (extendInt8# x#))))
+    countTrailingZeros (I8# x#) = I# (word2Int# (ctz8# (int2Word# (extendInt8# x#))))
 
 {-# RULES
 "fromIntegral/Int8->Int8" fromIntegral = id :: Int8 -> Int8
-"fromIntegral/a->Int8"    fromIntegral = \x -> case fromIntegral x of I# x# -> I8# (narrow8Int# x#)
-"fromIntegral/Int8->a"    fromIntegral = \(I8# x#) -> fromIntegral (I# x#)
+"fromIntegral/a->Int8"    fromIntegral = \x -> case fromIntegral x of I# x# -> I8# (narrowInt8# x#)
+"fromIntegral/Int8->a"    fromIntegral = \(I8# x#) -> fromIntegral (I# (extendInt8# x#))
   #-}
 
 {-# RULES
@@ -266,7 +266,7 @@ instance FiniteBits Int8 where
 -- Int16 is represented in the same way as Int. Operations may assume
 -- and must ensure that it holds only values from its logical range.
 
-data {-# CTYPE "HsInt16" #-} Int16 = I16# Int#
+data {-# CTYPE "HsInt16" #-} Int16 = I16# Int16#
 -- ^ 16-bit signed integer type
 
 -- See GHC.Classes#matching_overloaded_methods_in_rules
@@ -276,8 +276,8 @@ instance Eq Int16 where
     (/=) = neInt16
 
 eqInt16, neInt16 :: Int16 -> Int16 -> Bool
-eqInt16 (I16# x) (I16# y) = isTrue# (x ==# y)
-neInt16 (I16# x) (I16# y) = isTrue# (x /=# y)
+eqInt16 (I16# x) (I16# y) = isTrue# ((extendInt16# x) ==# (extendInt16# y))
+neInt16 (I16# x) (I16# y) = isTrue# ((extendInt16# x) /=# (extendInt16# y))
 {-# INLINE [1] eqInt16 #-}
 {-# INLINE [1] neInt16 #-}
 
@@ -293,10 +293,10 @@ instance Ord Int16 where
 {-# INLINE [1] ltInt16 #-}
 {-# INLINE [1] leInt16 #-}
 gtInt16, geInt16, ltInt16, leInt16 :: Int16 -> Int16 -> Bool
-(I16# x) `gtInt16` (I16# y) = isTrue# (x >#  y)
-(I16# x) `geInt16` (I16# y) = isTrue# (x >=# y)
-(I16# x) `ltInt16` (I16# y) = isTrue# (x <#  y)
-(I16# x) `leInt16` (I16# y) = isTrue# (x <=# y)
+(I16# x) `gtInt16` (I16# y) = isTrue# ((extendInt16# x) >#  (extendInt16# y))
+(I16# x) `geInt16` (I16# y) = isTrue# ((extendInt16# x) >=# (extendInt16# y))
+(I16# x) `ltInt16` (I16# y) = isTrue# ((extendInt16# x) <#  (extendInt16# y))
+(I16# x) `leInt16` (I16# y) = isTrue# ((extendInt16# x) <=# (extendInt16# y))
 
 -- | @since 2.01
 instance Show Int16 where
@@ -304,16 +304,16 @@ instance Show Int16 where
 
 -- | @since 2.01
 instance Num Int16 where
-    (I16# x#) + (I16# y#)  = I16# (narrow16Int# (x# +# y#))
-    (I16# x#) - (I16# y#)  = I16# (narrow16Int# (x# -# y#))
-    (I16# x#) * (I16# y#)  = I16# (narrow16Int# (x# *# y#))
-    negate (I16# x#)       = I16# (narrow16Int# (negateInt# x#))
+    (I16# x#) + (I16# y#)  = I16# (narrowInt16# ((extendInt16# x#) +# (extendInt16# y#)))
+    (I16# x#) - (I16# y#)  = I16# (narrowInt16# ((extendInt16# x#) -# (extendInt16# y#)))
+    (I16# x#) * (I16# y#)  = I16# (narrowInt16# ((extendInt16# x#) *# (extendInt16# y#)))
+    negate (I16# x#)       = I16# (narrowInt16# (negateInt# (extendInt16# x#)))
     abs x | x >= 0         = x
           | otherwise      = negate x
     signum x | x > 0       = 1
     signum 0               = 0
     signum _               = -1
-    fromInteger i          = I16# (narrow16Int# (integerToInt# i))
+    fromInteger i          = I16# (narrowInt16# (integerToInt# i))
 
 -- | @since 2.01
 instance Real Int16 where
@@ -329,9 +329,9 @@ instance Enum Int16 where
         | otherwise     = predError "Int16"
     toEnum i@(I# i#)
         | i >= fromIntegral (minBound::Int16) && i <= fromIntegral (maxBound::Int16)
-                        = I16# i#
+                        = I16# (narrowInt16# i#)
         | otherwise     = toEnumError "Int16" i (minBound::Int16, maxBound::Int16)
-    fromEnum (I16# x#)  = I# x#
+    fromEnum (I16# x#)  = I# (extendInt16# x#)
     enumFrom            = boundedEnumFrom
     enumFromThen        = boundedEnumFromThen
 
@@ -340,34 +340,34 @@ instance Integral Int16 where
     quot    x@(I16# x#) y@(I16# y#)
         | y == 0                     = divZeroError
         | y == (-1) && x == minBound = overflowError -- Note [Order of tests]
-        | otherwise                  = I16# (narrow16Int# (x# `quotInt#` y#))
+        | otherwise                  = I16# (narrowInt16# ((extendInt16# x#) `quotInt#` (extendInt16# y#)))
     rem       (I16# x#) y@(I16# y#)
         | y == 0                     = divZeroError
-        | otherwise                  = I16# (narrow16Int# (x# `remInt#` y#))
+        | otherwise                  = I16# (narrowInt16# ((extendInt16# x#) `remInt#` (extendInt16# y#)))
     div     x@(I16# x#) y@(I16# y#)
         | y == 0                     = divZeroError
         | y == (-1) && x == minBound = overflowError -- Note [Order of tests]
-        | otherwise                  = I16# (narrow16Int# (x# `divInt#` y#))
+        | otherwise                  = I16# (narrowInt16# ((extendInt16# x#) `divInt#` (extendInt16# y#)))
     mod       (I16# x#) y@(I16# y#)
         | y == 0                     = divZeroError
-        | otherwise                  = I16# (narrow16Int# (x# `modInt#` y#))
+        | otherwise                  = I16# (narrowInt16# ((extendInt16# x#) `modInt#` (extendInt16# y#)))
     quotRem x@(I16# x#) y@(I16# y#)
         | y == 0                     = divZeroError
           -- Note [Order of tests]
         | y == (-1) && x == minBound = (overflowError, 0)
-        | otherwise                  = case x# `quotRemInt#` y# of
+        | otherwise                  = case (extendInt16# x#) `quotRemInt#` (extendInt16# y#) of
                                        (# q, r #) ->
-                                           (I16# (narrow16Int# q),
-                                            I16# (narrow16Int# r))
+                                           (I16# (narrowInt16# q),
+                                            I16# (narrowInt16# r))
     divMod  x@(I16# x#) y@(I16# y#)
         | y == 0                     = divZeroError
           -- Note [Order of tests]
         | y == (-1) && x == minBound = (overflowError, 0)
-        | otherwise                  = case x# `divModInt#` y# of
+        | otherwise                  = case (extendInt16# x#) `divModInt#` (extendInt16# y#) of
                                        (# d, m #) ->
-                                           (I16# (narrow16Int# d),
-                                            I16# (narrow16Int# m))
-    toInteger (I16# x#)              = IS x#
+                                           (I16# (narrowInt16# d),
+                                            I16# (narrowInt16# m))
+    toInteger (I16# x#)              = IS (extendInt16# x#)
 
 -- | @since 2.01
 instance Bounded Int16 where
@@ -391,34 +391,34 @@ instance Bits Int16 where
     {-# INLINE testBit #-}
     {-# INLINE popCount #-}
 
-    (I16# x#) .&.   (I16# y#)  = I16# (x# `andI#` y#)
-    (I16# x#) .|.   (I16# y#)  = I16# (x# `orI#`  y#)
-    (I16# x#) `xor` (I16# y#)  = I16# (x# `xorI#` y#)
-    complement (I16# x#)       = I16# (notI# x#)
+    (I16# x#) .&.   (I16# y#)  = I16# (narrowInt16# ((extendInt16# x#) `andI#` (extendInt16# y#)))
+    (I16# x#) .|.   (I16# y#)  = I16# (narrowInt16# ((extendInt16# x#) `orI#`  (extendInt16# y#)))
+    (I16# x#) `xor` (I16# y#)  = I16# (narrowInt16# ((extendInt16# x#) `xorI#` (extendInt16# y#)))
+    complement (I16# x#)       = I16# (narrowInt16# (notI# (extendInt16# x#)))
     (I16# x#) `shift` (I# i#)
-        | isTrue# (i# >=# 0#)  = I16# (narrow16Int# (x# `iShiftL#` i#))
-        | otherwise            = I16# (x# `iShiftRA#` negateInt# i#)
+        | isTrue# (i# >=# 0#)  = I16# (narrowInt16# ((extendInt16# x#) `iShiftL#` i#))
+        | otherwise            = I16# (narrowInt16# ((extendInt16# x#) `iShiftRA#` negateInt# i#))
     (I16# x#) `shiftL`       (I# i#)
-        | isTrue# (i# >=# 0#)  = I16# (narrow16Int# (x# `iShiftL#` i#))
+        | isTrue# (i# >=# 0#)  = I16# (narrowInt16# ((extendInt16# x#) `iShiftL#` i#))
         | otherwise            = overflowError
-    (I16# x#) `unsafeShiftL` (I# i#) = I16# (narrow16Int# (x# `uncheckedIShiftL#` i#))
+    (I16# x#) `unsafeShiftL` (I# i#) = I16# (narrowInt16# ((extendInt16# x#) `uncheckedIShiftL#` i#))
     (I16# x#) `shiftR`       (I# i#)
-        | isTrue# (i# >=# 0#)  = I16# (x# `iShiftRA#` i#)
+        | isTrue# (i# >=# 0#)  = I16# (narrowInt16# ((extendInt16# x#) `iShiftRA#` i#))
         | otherwise            = overflowError
-    (I16# x#) `unsafeShiftR` (I# i#) = I16# (x# `uncheckedIShiftRA#` i#)
+    (I16# x#) `unsafeShiftR` (I# i#) = I16# (narrowInt16# ((extendInt16# x#) `uncheckedIShiftRA#` i#))
     (I16# x#) `rotate` (I# i#)
         | isTrue# (i'# ==# 0#)
         = I16# x#
         | otherwise
-        = I16# (narrow16Int# (word2Int# ((x'# `uncheckedShiftL#` i'#) `or#`
+        = I16# (narrowInt16# (word2Int# ((x'# `uncheckedShiftL#` i'#) `or#`
                                          (x'# `uncheckedShiftRL#` (16# -# i'#)))))
         where
-        !x'# = narrow16Word# (int2Word# x#)
+        !x'# = narrow16Word# (int2Word# (extendInt16# x#))
         !i'# = word2Int# (int2Word# i# `and#` 15##)
     bitSizeMaybe i             = Just (finiteBitSize i)
     bitSize i                  = finiteBitSize i
     isSigned _                 = True
-    popCount (I16# x#)         = I# (word2Int# (popCnt16# (int2Word# x#)))
+    popCount (I16# x#)         = I# (word2Int# (popCnt16# (int2Word# (extendInt16# x#))))
     bit                        = bitDefault
     testBit                    = testBitDefault
 
@@ -427,15 +427,15 @@ instance FiniteBits Int16 where
     {-# INLINE countLeadingZeros #-}
     {-# INLINE countTrailingZeros #-}
     finiteBitSize _ = 16
-    countLeadingZeros  (I16# x#) = I# (word2Int# (clz16# (int2Word# x#)))
-    countTrailingZeros (I16# x#) = I# (word2Int# (ctz16# (int2Word# x#)))
+    countLeadingZeros  (I16# x#) = I# (word2Int# (clz16# (int2Word# (extendInt16# x#))))
+    countTrailingZeros (I16# x#) = I# (word2Int# (ctz16# (int2Word# (extendInt16# x#))))
 
 {-# RULES
-"fromIntegral/Word8->Int16"  fromIntegral = \(W8# x#) -> I16# (word2Int# x#)
-"fromIntegral/Int8->Int16"   fromIntegral = \(I8# x#) -> I16# x#
+"fromIntegral/Word8->Int16"  fromIntegral = \(W8# x#) -> I16# (narrowInt16# (word2Int# x#))
+"fromIntegral/Int8->Int16"   fromIntegral = \(I8# x#) -> I16# (narrowInt16# (extendInt8# x#))
 "fromIntegral/Int16->Int16"  fromIntegral = id :: Int16 -> Int16
-"fromIntegral/a->Int16"      fromIntegral = \x -> case fromIntegral x of I# x# -> I16# (narrow16Int# x#)
-"fromIntegral/Int16->a"      fromIntegral = \(I16# x#) -> fromIntegral (I# x#)
+"fromIntegral/a->Int16"      fromIntegral = \x -> case fromIntegral x of I# x# -> I16# (narrowInt16# x#)
+"fromIntegral/Int16->a"      fromIntegral = \(I16# x#) -> fromIntegral (I# (extendInt16# x#))
   #-}
 
 {-# RULES
@@ -478,7 +478,7 @@ instance FiniteBits Int16 where
 -- from its logical range.
 #endif
 
-data {-# CTYPE "HsInt32" #-} Int32 = I32# Int#
+data {-# CTYPE "HsInt32" #-} Int32 = I32# Int32#
 -- ^ 32-bit signed integer type
 
 -- See GHC.Classes#matching_overloaded_methods_in_rules
@@ -488,8 +488,8 @@ instance Eq Int32 where
     (/=) = neInt32
 
 eqInt32, neInt32 :: Int32 -> Int32 -> Bool
-eqInt32 (I32# x) (I32# y) = isTrue# (x ==# y)
-neInt32 (I32# x) (I32# y) = isTrue# (x /=# y)
+eqInt32 (I32# x) (I32# y) = isTrue# ((extendInt32# x) ==# (extendInt32# y))
+neInt32 (I32# x) (I32# y) = isTrue# ((extendInt32# x) /=# (extendInt32# y))
 {-# INLINE [1] eqInt32 #-}
 {-# INLINE [1] neInt32 #-}
 
@@ -505,10 +505,10 @@ instance Ord Int32 where
 {-# INLINE [1] ltInt32 #-}
 {-# INLINE [1] leInt32 #-}
 gtInt32, geInt32, ltInt32, leInt32 :: Int32 -> Int32 -> Bool
-(I32# x) `gtInt32` (I32# y) = isTrue# (x >#  y)
-(I32# x) `geInt32` (I32# y) = isTrue# (x >=# y)
-(I32# x) `ltInt32` (I32# y) = isTrue# (x <#  y)
-(I32# x) `leInt32` (I32# y) = isTrue# (x <=# y)
+(I32# x) `gtInt32` (I32# y) = isTrue# ((extendInt32# x) >#  (extendInt32# y))
+(I32# x) `geInt32` (I32# y) = isTrue# ((extendInt32# x) >=# (extendInt32# y))
+(I32# x) `ltInt32` (I32# y) = isTrue# ((extendInt32# x) <#  (extendInt32# y))
+(I32# x) `leInt32` (I32# y) = isTrue# ((extendInt32# x) <=# (extendInt32# y))
 
 -- | @since 2.01
 instance Show Int32 where
@@ -516,16 +516,16 @@ instance Show Int32 where
 
 -- | @since 2.01
 instance Num Int32 where
-    (I32# x#) + (I32# y#)  = I32# (narrow32Int# (x# +# y#))
-    (I32# x#) - (I32# y#)  = I32# (narrow32Int# (x# -# y#))
-    (I32# x#) * (I32# y#)  = I32# (narrow32Int# (x# *# y#))
-    negate (I32# x#)       = I32# (narrow32Int# (negateInt# x#))
+    (I32# x#) + (I32# y#)  = I32# (narrowInt32# ((extendInt32# x#) +# (extendInt32# y#)))
+    (I32# x#) - (I32# y#)  = I32# (narrowInt32# ((extendInt32# x#) -# (extendInt32# y#)))
+    (I32# x#) * (I32# y#)  = I32# (narrowInt32# ((extendInt32# x#) *# (extendInt32# y#)))
+    negate (I32# x#)       = I32# (narrowInt32# (negateInt# (extendInt32# x#)))
     abs x | x >= 0         = x
           | otherwise      = negate x
     signum x | x > 0       = 1
     signum 0               = 0
     signum _               = -1
-    fromInteger i          = I32# (narrow32Int# (integerToInt# i))
+    fromInteger i          = I32# (narrowInt32# (integerToInt# i))
 
 -- | @since 2.01
 instance Enum Int32 where
@@ -540,10 +540,10 @@ instance Enum Int32 where
 #else
     toEnum i@(I# i#)
         | i >= fromIntegral (minBound::Int32) && i <= fromIntegral (maxBound::Int32)
-                        = I32# i#
+                        = I32# (narrowInt32# i#)
         | otherwise     = toEnumError "Int32" i (minBound::Int32, maxBound::Int32)
 #endif
-    fromEnum (I32# x#)  = I# x#
+    fromEnum (I32# x#)  = I# (extendInt32# x#)
     enumFrom            = boundedEnumFrom
     enumFromThen        = boundedEnumFromThen
 
@@ -552,42 +552,42 @@ instance Integral Int32 where
     quot    x@(I32# x#) y@(I32# y#)
         | y == 0                     = divZeroError
         | y == (-1) && x == minBound = overflowError -- Note [Order of tests]
-        | otherwise                  = I32# (narrow32Int# (x# `quotInt#` y#))
+        | otherwise                  = I32# (narrowInt32# ((extendInt32# x#) `quotInt#` (extendInt32# y#)))
     rem       (I32# x#) y@(I32# y#)
         | y == 0                     = divZeroError
           -- The quotRem CPU instruction fails for minBound `quotRem` -1,
           -- but minBound `rem` -1 is well-defined (0). We therefore
           -- special-case it.
         | y == (-1)                  = 0
-        | otherwise                  = I32# (narrow32Int# (x# `remInt#` y#))
+        | otherwise                  = I32# (narrowInt32# ((extendInt32# x#) `remInt#` (extendInt32# y#)))
     div     x@(I32# x#) y@(I32# y#)
         | y == 0                     = divZeroError
         | y == (-1) && x == minBound = overflowError -- Note [Order of tests]
-        | otherwise                  = I32# (narrow32Int# (x# `divInt#` y#))
+        | otherwise                  = I32# (narrowInt32# ((extendInt32# x#) `divInt#` (extendInt32# y#)))
     mod       (I32# x#) y@(I32# y#)
         | y == 0                     = divZeroError
           -- The divMod CPU instruction fails for minBound `divMod` -1,
           -- but minBound `mod` -1 is well-defined (0). We therefore
           -- special-case it.
         | y == (-1)                  = 0
-        | otherwise                  = I32# (narrow32Int# (x# `modInt#` y#))
+        | otherwise                  = I32# (narrowInt32# ((extendInt32# x#) `modInt#` (extendInt32# y#)))
     quotRem x@(I32# x#) y@(I32# y#)
         | y == 0                     = divZeroError
           -- Note [Order of tests]
         | y == (-1) && x == minBound = (overflowError, 0)
-        | otherwise                  = case x# `quotRemInt#` y# of
+        | otherwise                  = case (extendInt32# x#) `quotRemInt#` (extendInt32# y#) of
                                        (# q, r #) ->
-                                           (I32# (narrow32Int# q),
-                                            I32# (narrow32Int# r))
+                                           (I32# (narrowInt32# q),
+                                            I32# (narrowInt32# r))
     divMod  x@(I32# x#) y@(I32# y#)
         | y == 0                     = divZeroError
           -- Note [Order of tests]
         | y == (-1) && x == minBound = (overflowError, 0)
-        | otherwise                  = case x# `divModInt#` y# of
+        | otherwise                  = case (extendInt32# x#) `divModInt#` (extendInt32# y#) of
                                        (# d, m #) ->
-                                           (I32# (narrow32Int# d),
-                                            I32# (narrow32Int# m))
-    toInteger (I32# x#)              = IS x#
+                                           (I32# (narrowInt32# d),
+                                            I32# (narrowInt32# m))
+    toInteger (I32# x#)              = IS (extendInt32# x#)
 
 -- | @since 2.01
 instance Read Int32 where
@@ -600,35 +600,35 @@ instance Bits Int32 where
     {-# INLINE testBit #-}
     {-# INLINE popCount #-}
 
-    (I32# x#) .&.   (I32# y#)  = I32# (x# `andI#` y#)
-    (I32# x#) .|.   (I32# y#)  = I32# (x# `orI#`  y#)
-    (I32# x#) `xor` (I32# y#)  = I32# (x# `xorI#` y#)
-    complement (I32# x#)       = I32# (notI# x#)
+    (I32# x#) .&.   (I32# y#)  = I32# (narrowInt32# ((extendInt32# x#) `andI#` (extendInt32# y#)))
+    (I32# x#) .|.   (I32# y#)  = I32# (narrowInt32# ((extendInt32# x#) `orI#`  (extendInt32# y#)))
+    (I32# x#) `xor` (I32# y#)  = I32# (narrowInt32# ((extendInt32# x#) `xorI#` (extendInt32# y#)))
+    complement (I32# x#)       = I32# (narrowInt32# (notI# (extendInt32# x#)))
     (I32# x#) `shift` (I# i#)
-        | isTrue# (i# >=# 0#)  = I32# (narrow32Int# (x# `iShiftL#` i#))
-        | otherwise            = I32# (x# `iShiftRA#` negateInt# i#)
+        | isTrue# (i# >=# 0#)  = I32# (narrowInt32# ((extendInt32# x#) `iShiftL#` i#))
+        | otherwise            = I32# (narrowInt32# ((extendInt32# x#) `iShiftRA#` negateInt# i#))
     (I32# x#) `shiftL`       (I# i#)
-        | isTrue# (i# >=# 0#)  = I32# (narrow32Int# (x# `iShiftL#` i#))
+        | isTrue# (i# >=# 0#)  = I32# (narrowInt32# ((extendInt32# x#) `iShiftL#` i#))
         | otherwise            = overflowError
     (I32# x#) `unsafeShiftL` (I# i#) =
-        I32# (narrow32Int# (x# `uncheckedIShiftL#` i#))
+        I32# (narrowInt32# ((extendInt32# x#) `uncheckedIShiftL#` i#))
     (I32# x#) `shiftR`       (I# i#)
-        | isTrue# (i# >=# 0#)  = I32# (x# `iShiftRA#` i#)
+        | isTrue# (i# >=# 0#)  = I32# (narrowInt32# ((extendInt32# x#) `iShiftRA#` i#))
         | otherwise            = overflowError
-    (I32# x#) `unsafeShiftR` (I# i#) = I32# (x# `uncheckedIShiftRA#` i#)
+    (I32# x#) `unsafeShiftR` (I# i#) = I32# (narrowInt32# ((extendInt32# x#) `uncheckedIShiftRA#` i#))
     (I32# x#) `rotate` (I# i#)
         | isTrue# (i'# ==# 0#)
         = I32# x#
         | otherwise
-        = I32# (narrow32Int# (word2Int# ((x'# `uncheckedShiftL#` i'#) `or#`
+        = I32# (narrowInt32# (word2Int# ((x'# `uncheckedShiftL#` i'#) `or#`
                                          (x'# `uncheckedShiftRL#` (32# -# i'#)))))
         where
-        !x'# = narrow32Word# (int2Word# x#)
+        !x'# = narrow32Word# (int2Word# (extendInt32# x#))
         !i'# = word2Int# (int2Word# i# `and#` 31##)
     bitSizeMaybe i             = Just (finiteBitSize i)
     bitSize i                  = finiteBitSize i
     isSigned _                 = True
-    popCount (I32# x#)         = I# (word2Int# (popCnt32# (int2Word# x#)))
+    popCount (I32# x#)         = I# (word2Int# (popCnt32# (int2Word# (extendInt32# x#))))
     bit                        = bitDefault
     testBit                    = testBitDefault
 
@@ -637,17 +637,17 @@ instance FiniteBits Int32 where
     {-# INLINE countLeadingZeros #-}
     {-# INLINE countTrailingZeros #-}
     finiteBitSize _ = 32
-    countLeadingZeros  (I32# x#) = I# (word2Int# (clz32# (int2Word# x#)))
-    countTrailingZeros (I32# x#) = I# (word2Int# (ctz32# (int2Word# x#)))
+    countLeadingZeros  (I32# x#) = I# (word2Int# (clz32# (int2Word# (extendInt32# x#))))
+    countTrailingZeros (I32# x#) = I# (word2Int# (ctz32# (int2Word# (extendInt32# x#))))
 
 {-# RULES
-"fromIntegral/Word8->Int32"  fromIntegral = \(W8# x#) -> I32# (word2Int# x#)
-"fromIntegral/Word16->Int32" fromIntegral = \(W16# x#) -> I32# (word2Int# x#)
-"fromIntegral/Int8->Int32"   fromIntegral = \(I8# x#) -> I32# x#
-"fromIntegral/Int16->Int32"  fromIntegral = \(I16# x#) -> I32# x#
+"fromIntegral/Word8->Int32"  fromIntegral = \(W8# x#) -> I32# (narrowInt32# (word2Int# x#))
+"fromIntegral/Word16->Int32" fromIntegral = \(W16# x#) -> I32# (narrowInt32# (word2Int# x#))
+"fromIntegral/Int8->Int32"   fromIntegral = \(I8# x#) -> I32# (narrowInt32# (extendInt8# x#))
+"fromIntegral/Int16->Int32"  fromIntegral = \(I16# x#) -> I32# (narrowInt32# (extendInt16# x#))
 "fromIntegral/Int32->Int32"  fromIntegral = id :: Int32 -> Int32
-"fromIntegral/a->Int32"      fromIntegral = \x -> case fromIntegral x of I# x# -> I32# (narrow32Int# x#)
-"fromIntegral/Int32->a"      fromIntegral = \(I32# x#) -> fromIntegral (I# x#)
+"fromIntegral/a->Int32"      fromIntegral = \x -> case fromIntegral x of I# x# -> I32# (narrowInt32# x#)
+"fromIntegral/Int32->a"      fromIntegral = \(I32# x#) -> fromIntegral (I# (extendInt32# x#))
   #-}
 
 {-# RULES
diff --git a/libraries/base/GHC/Storable.hs b/libraries/base/GHC/Storable.hs
index d9b9382211..5324837168 100644
--- a/libraries/base/GHC/Storable.hs
+++ b/libraries/base/GHC/Storable.hs
@@ -91,15 +91,15 @@ readDoubleOffPtr (Ptr a) (I# i)
 readStablePtrOffPtr (Ptr a) (I# i)
   = IO $ \s -> case readStablePtrOffAddr# a i s of (# s2, x #) -> (# s2, StablePtr x #)
 readInt8OffPtr (Ptr a) (I# i)
-  = IO $ \s -> case readInt8OffAddr# a i s      of (# s2, x #) -> (# s2, I8# x #)
+  = IO $ \s -> case readInt8OffAddr# a i s      of (# s2, x #) -> (# s2, I8# (narrowInt8# x) #)
 readWord8OffPtr (Ptr a) (I# i)
   = IO $ \s -> case readWord8OffAddr# a i s     of (# s2, x #) -> (# s2, W8# x #)
 readInt16OffPtr (Ptr a) (I# i)
-  = IO $ \s -> case readInt16OffAddr# a i s     of (# s2, x #) -> (# s2, I16# x #)
+  = IO $ \s -> case readInt16OffAddr# a i s     of (# s2, x #) -> (# s2, I16# (narrowInt16# x) #)
 readWord16OffPtr (Ptr a) (I# i)
   = IO $ \s -> case readWord16OffAddr# a i s    of (# s2, x #) -> (# s2, W16# x #)
 readInt32OffPtr (Ptr a) (I# i)
-  = IO $ \s -> case readInt32OffAddr# a i s     of (# s2, x #) -> (# s2, I32# x #)
+  = IO $ \s -> case readInt32OffAddr# a i s     of (# s2, x #) -> (# s2, I32# (narrowInt32# x) #)
 readWord32OffPtr (Ptr a) (I# i)
   = IO $ \s -> case readWord32OffAddr# a i s    of (# s2, x #) -> (# s2, W32# x #)
 readInt64OffPtr (Ptr a) (I# i)
@@ -141,15 +141,15 @@ writeDoubleOffPtr (Ptr a) (I# i) (D# x)
 writeStablePtrOffPtr (Ptr a) (I# i) (StablePtr x)
   = IO $ \s -> case writeStablePtrOffAddr# a i x s of s2 -> (# s2 , () #)
 writeInt8OffPtr (Ptr a) (I# i) (I8# x)
-  = IO $ \s -> case writeInt8OffAddr# a i x s      of s2 -> (# s2, () #)
+  = IO $ \s -> case writeInt8OffAddr# a i (extendInt8# x) s      of s2 -> (# s2, () #)
 writeWord8OffPtr (Ptr a) (I# i) (W8# x)
   = IO $ \s -> case writeWord8OffAddr# a i x s     of s2 -> (# s2, () #)
 writeInt16OffPtr (Ptr a) (I# i) (I16# x)
-  = IO $ \s -> case writeInt16OffAddr# a i x s     of s2 -> (# s2, () #)
+  = IO $ \s -> case writeInt16OffAddr# a i (extendInt16# x) s     of s2 -> (# s2, () #)
 writeWord16OffPtr (Ptr a) (I# i) (W16# x)
   = IO $ \s -> case writeWord16OffAddr# a i x s    of s2 -> (# s2, () #)
 writeInt32OffPtr (Ptr a) (I# i) (I32# x)
-  = IO $ \s -> case writeInt32OffAddr# a i x s     of s2 -> (# s2, () #)
+  = IO $ \s -> case writeInt32OffAddr# a i (extendInt32# x) s     of s2 -> (# s2, () #)
 writeWord32OffPtr (Ptr a) (I# i) (W32# x)
   = IO $ \s -> case writeWord32OffAddr# a i x s    of s2 -> (# s2, () #)
 writeInt64OffPtr (Ptr a) (I# i) (I64# x)