[CmmSized Int] unpacked ints, part 2

(cherry picked from commit 872b3b35e269eaea771d0f98a9bce6ce9ff8f084)

10 files changed, 221 insertions, 28 deletions

diff --git a/compiler/GHC/ByteCode/Asm.hs b/compiler/GHC/ByteCode/Asm.hs
index 92255f9ea0..ff8bacd6cc 100644
--- a/compiler/GHC/ByteCode/Asm.hs
+++ b/compiler/GHC/ByteCode/Asm.hs
@@ -464,6 +464,12 @@ assembleI platform i = case i of
     literal (LitNumber nt i) = case nt of
       LitNumInt     -> int (fromIntegral i)
       LitNumWord    -> int (fromIntegral i)
+      LitNumInt8    -> int8 (fromIntegral i)
+      LitNumWord8   -> int8 (fromIntegral i)
+      LitNumInt16   -> int16 (fromIntegral i)
+      LitNumWord16  -> int16 (fromIntegral i)
+      LitNumInt32   -> int32 (fromIntegral i)
+      LitNumWord32  -> int32 (fromIntegral i)
       LitNumInt64   -> int64 (fromIntegral i)
       LitNumWord64  -> int64 (fromIntegral i)
       LitNumInteger -> panic "GHC.ByteCode.Asm.literal: LitNumInteger"
@@ -478,6 +484,9 @@ assembleI platform i = case i of
     float = words . mkLitF
     double = words . mkLitD platform
     int = words . mkLitI
+    int8 = words . mkLitI64 platform
+    int16 = words . mkLitI64 platform
+    int32 = words . mkLitI64 platform
     int64 = words . mkLitI64 platform
     words ws = lit (map BCONPtrWord ws)
     word w = words [w]
diff --git a/compiler/GHC/Core/Opt/ConstantFold.hs b/compiler/GHC/Core/Opt/ConstantFold.hs
index 73b266de11..abbacb67f8 100644
--- a/compiler/GHC/Core/Opt/ConstantFold.hs
+++ b/compiler/GHC/Core/Opt/ConstantFold.hs
@@ -625,8 +625,14 @@ isMinBound :: Platform -> Literal -> Bool
 isMinBound _        (LitChar c)        = c == minBound
 isMinBound platform (LitNumber nt i)   = case nt of
    LitNumInt     -> i == platformMinInt platform
+   LitNumInt8    -> i == toInteger (minBound :: Int8)
+   LitNumInt16   -> i == toInteger (minBound :: Int16)
+   LitNumInt32   -> i == toInteger (minBound :: Int32)
    LitNumInt64   -> i == toInteger (minBound :: Int64)
    LitNumWord    -> i == 0
+   LitNumWord8   -> i == 0
+   LitNumWord16  -> i == 0
+   LitNumWord32  -> i == 0
    LitNumWord64  -> i == 0
    LitNumNatural -> i == 0
    LitNumInteger -> False
@@ -636,8 +642,14 @@ isMaxBound :: Platform -> Literal -> Bool
 isMaxBound _        (LitChar c)        = c == maxBound
 isMaxBound platform (LitNumber nt i)   = case nt of
    LitNumInt     -> i == platformMaxInt platform
+   LitNumInt8    -> i == toInteger (maxBound :: Int8)
+   LitNumInt16   -> i == toInteger (maxBound :: Int16)
+   LitNumInt32   -> i == toInteger (maxBound :: Int32)
    LitNumInt64   -> i == toInteger (maxBound :: Int64)
    LitNumWord    -> i == platformMaxWord platform
+   LitNumWord8   -> i == toInteger (maxBound :: Word8)
+   LitNumWord16  -> i == toInteger (maxBound :: Word16)
+   LitNumWord32  -> i == toInteger (maxBound :: Word32)
    LitNumWord64  -> i == toInteger (maxBound :: Word64)
    LitNumNatural -> False
    LitNumInteger -> False
diff --git a/compiler/GHC/CoreToByteCode.hs b/compiler/GHC/CoreToByteCode.hs
index f8cb9737d9..a616f0c6c6 100644
--- a/compiler/GHC/CoreToByteCode.hs
+++ b/compiler/GHC/CoreToByteCode.hs
@@ -1387,6 +1387,12 @@ primRepToFFIType platform r
      VoidRep     -> FFIVoid
      IntRep      -> signed_word
      WordRep     -> unsigned_word
+     Int8Rep     -> FFISInt8
+     Word8Rep    -> FFIUInt8
+     Int16Rep    -> FFISInt16
+     Word16Rep   -> FFIUInt16
+     Int32Rep    -> FFISInt32
+     Word32Rep   -> FFIUInt32
      Int64Rep    -> FFISInt64
      Word64Rep   -> FFIUInt64
      AddrRep     -> FFIPointer
@@ -1405,6 +1411,12 @@ mkDummyLiteral platform pr
    = case pr of
         IntRep    -> mkLitInt  platform 0
         WordRep   -> mkLitWord platform 0
+        Int8Rep   -> mkLitInt8 0
+        Word8Rep  -> mkLitWord8 0
+        Int16Rep  -> mkLitInt16 0
+        Word16Rep -> mkLitWord16 0
+        Int32Rep  -> mkLitInt32 0
+        Word32Rep -> mkLitWord32 0
         Int64Rep  -> mkLitInt64 0
         Word64Rep -> mkLitWord64 0
         AddrRep   -> LitNullAddr
@@ -1637,6 +1649,12 @@ pushAtom _ _ (AnnLit lit) = do
         LitNumber nt _  -> case nt of
           LitNumInt     -> code N
           LitNumWord    -> code N
+          LitNumInt8    -> code (toArgRep Int8Rep)
+          LitNumWord8   -> code (toArgRep Word8Rep)
+          LitNumInt16   -> code (toArgRep Int16Rep)
+          LitNumWord16  -> code (toArgRep Word16Rep)
+          LitNumInt32   -> code (toArgRep Int32Rep)
+          LitNumWord32  -> code (toArgRep Word32Rep)
           LitNumInt64   -> code L
           LitNumWord64  -> code L
           -- No LitInteger's or LitNatural's should be left by the time this is
diff --git a/compiler/GHC/HsToCore/Foreign/Call.hs b/compiler/GHC/HsToCore/Foreign/Call.hs
index 56ec46cd99..e5679e1c57 100644
--- a/compiler/GHC/HsToCore/Foreign/Call.hs
+++ b/compiler/GHC/HsToCore/Foreign/Call.hs
@@ -356,35 +356,13 @@ resultWrapper result_ty
   , Just data_con <- isDataProductTyCon_maybe tycon  -- One constructor, no existentials
   , [Scaled _ unwrapped_res_ty] <- dataConInstOrigArgTys data_con tycon_arg_tys  -- One argument
   = do { dflags <- getDynFlags
-       ; let platform = targetPlatform dflags
        ; (maybe_ty, wrapper) <- resultWrapper unwrapped_res_ty
-       ; let narrow_wrapper = maybeNarrow platform tycon
-             marshal_con e  = Var (dataConWrapId data_con)
+       ; let marshal_con e  = Var (dataConWrapId data_con)
                               `mkTyApps` tycon_arg_tys
-                              `App` wrapper (narrow_wrapper e)
+                              `App` wrapper e
        ; return (maybe_ty, marshal_con) }
 
   | otherwise
   = pprPanic "resultWrapper" (ppr result_ty)
   where
     maybe_tc_app = splitTyConApp_maybe result_ty
-
--- When the result of a foreign call is smaller than the word size, we
--- need to sign- or zero-extend the result up to the word size.  The C
--- standard appears to say that this is the responsibility of the
--- caller, not the callee.
-
-maybeNarrow :: Platform -> TyCon -> (CoreExpr -> CoreExpr)
-maybeNarrow platform tycon
-  | tycon `hasKey` int8TyConKey   = \e -> App (Var (mkPrimOpId Narrow8IntOp)) e
-  | tycon `hasKey` int16TyConKey  = \e -> App (Var (mkPrimOpId Narrow16IntOp)) e
-  | tycon `hasKey` int32TyConKey
-  , platformWordSizeInBytes platform > 4
-  = \e -> App (Var (mkPrimOpId Narrow32IntOp)) e
-
-  | tycon `hasKey` word8TyConKey  = \e -> App (Var (mkPrimOpId Narrow8WordOp)) e
-  | tycon `hasKey` word16TyConKey = \e -> App (Var (mkPrimOpId Narrow16WordOp)) e
-  | tycon `hasKey` word32TyConKey
-  , platformWordSizeInBytes platform > 4
-  = \e -> App (Var (mkPrimOpId Narrow32WordOp)) e
-  | otherwise                     = id
diff --git a/compiler/GHC/HsToCore/Foreign/Decl.hs b/compiler/GHC/HsToCore/Foreign/Decl.hs
index 224fd23c3d..ca7e56bec5 100644
--- a/compiler/GHC/HsToCore/Foreign/Decl.hs
+++ b/compiler/GHC/HsToCore/Foreign/Decl.hs
@@ -849,6 +849,10 @@ primTyDescChar platform ty
  = case typePrimRep1 (getPrimTyOf ty) of
      IntRep      -> signed_word
      WordRep     -> unsigned_word
+     Int8Rep     -> 'B'
+     Word8Rep    -> 'b'
+     Int16Rep    -> 'S'
+     Word16Rep   -> 's'
      Int32Rep    -> 'W'
      Word32Rep   -> 'w'
      Int64Rep    -> 'L'
diff --git a/compiler/GHC/Runtime/Heap/Inspect.hs b/compiler/GHC/Runtime/Heap/Inspect.hs
index 8de6a0d39d..597bd8905d 100644
--- a/compiler/GHC/Runtime/Heap/Inspect.hs
+++ b/compiler/GHC/Runtime/Heap/Inspect.hs
@@ -467,6 +467,10 @@ repPrim t = rep where
     | t == wordPrimTyCon             = text $ show (build x :: Word)
     | t == floatPrimTyCon            = text $ show (build x :: Float)
     | t == doublePrimTyCon           = text $ show (build x :: Double)
+    | t == int8PrimTyCon             = text $ show (build x :: Int8)
+    | t == word8PrimTyCon            = text $ show (build x :: Word8)
+    | t == int16PrimTyCon            = text $ show (build x :: Int16)
+    | t == word16PrimTyCon           = text $ show (build x :: Word16)
     | t == int32PrimTyCon            = text $ show (build x :: Int32)
     | t == word32PrimTyCon           = text $ show (build x :: Word32)
     | t == int64PrimTyCon            = text $ show (build x :: Int64)
diff --git a/compiler/GHC/StgToCmm/Utils.hs b/compiler/GHC/StgToCmm/Utils.hs
index dbb4481d72..8cca28cc5a 100644
--- a/compiler/GHC/StgToCmm/Utils.hs
+++ b/compiler/GHC/StgToCmm/Utils.hs
@@ -106,8 +106,14 @@ mkSimpleLit platform = \case
                                           (wordWidth platform)
    LitNullAddr                  -> zeroCLit platform
    (LitNumber LitNumInt i)      -> CmmInt i (wordWidth platform)
+   (LitNumber LitNumInt8 i)     -> CmmInt i W8
+   (LitNumber LitNumInt16 i)    -> CmmInt i W16
+   (LitNumber LitNumInt32 i)    -> CmmInt i W32
    (LitNumber LitNumInt64 i)    -> CmmInt i W64
    (LitNumber LitNumWord i)     -> CmmInt i (wordWidth platform)
+   (LitNumber LitNumWord8 i)    -> CmmInt i W8
+   (LitNumber LitNumWord16 i)   -> CmmInt i W16
+   (LitNumber LitNumWord32 i)   -> CmmInt i W32
    (LitNumber LitNumWord64 i)   -> CmmInt i W64
    (LitFloat r)                 -> CmmFloat r W32
    (LitDouble r)                -> CmmFloat r W64
diff --git a/compiler/GHC/Types/Literal.hs b/compiler/GHC/Types/Literal.hs
index 461f4ac70a..3e72433f15 100644
--- a/compiler/GHC/Types/Literal.hs
+++ b/compiler/GHC/Types/Literal.hs
@@ -17,6 +17,12 @@ module GHC.Types.Literal
         -- ** Creating Literals
         , mkLitInt, mkLitIntWrap, mkLitIntWrapC, mkLitIntUnchecked
         , mkLitWord, mkLitWordWrap, mkLitWordWrapC
+        , mkLitInt8, mkLitInt8Wrap
+        , mkLitWord8, mkLitWord8Wrap
+        , mkLitInt16, mkLitInt16Wrap
+        , mkLitWord16, mkLitWord16Wrap
+        , mkLitInt32, mkLitInt32Wrap
+        , mkLitWord32, mkLitWord32Wrap
         , mkLitInt64, mkLitInt64Wrap
         , mkLitWord64, mkLitWord64Wrap
         , mkLitFloat, mkLitDouble
@@ -152,8 +158,14 @@ data LitNumType
   = LitNumInteger -- ^ @Integer@ (see Note [BigNum literals])
   | LitNumNatural -- ^ @Natural@ (see Note [BigNum literals])
   | LitNumInt     -- ^ @Int#@ - according to target machine
+  | LitNumInt8    -- ^ @Int8#@ - exactly 8 bits
+  | LitNumInt16   -- ^ @Int16#@ - exactly 16 bits
+  | LitNumInt32   -- ^ @Int32#@ - exactly 32 bits
   | LitNumInt64   -- ^ @Int64#@ - exactly 64 bits
   | LitNumWord    -- ^ @Word#@ - according to target machine
+  | LitNumWord8   -- ^ @Word8#@ - exactly 8 bits
+  | LitNumWord16  -- ^ @Word16#@ - exactly 16 bits
+  | LitNumWord32  -- ^ @Word32#@ - exactly 32 bits
   | LitNumWord64  -- ^ @Word64#@ - exactly 64 bits
   deriving (Data,Enum,Eq,Ord)
 
@@ -163,8 +175,14 @@ litNumIsSigned nt = case nt of
   LitNumInteger -> True
   LitNumNatural -> False
   LitNumInt     -> True
+  LitNumInt8    -> True
+  LitNumInt16   -> True
+  LitNumInt32   -> True
   LitNumInt64   -> True
   LitNumWord    -> False
+  LitNumWord8   -> False
+  LitNumWord16  -> False
+  LitNumWord32  -> False
   LitNumWord64  -> False
 
 {-
@@ -290,6 +308,12 @@ wrapLitNumber platform v@(LitNumber nt i) = case nt of
   LitNumWord -> case platformWordSize platform of
     PW4 -> LitNumber nt (toInteger (fromIntegral i :: Word32))
     PW8 -> LitNumber nt (toInteger (fromIntegral i :: Word64))
+  LitNumInt8    -> LitNumber nt (toInteger (fromIntegral i :: Int8))
+  LitNumWord8   -> LitNumber nt (toInteger (fromIntegral i :: Word8))
+  LitNumInt16   -> LitNumber nt (toInteger (fromIntegral i :: Int16))
+  LitNumWord16  -> LitNumber nt (toInteger (fromIntegral i :: Word16))
+  LitNumInt32   -> LitNumber nt (toInteger (fromIntegral i :: Int32))
+  LitNumWord32  -> LitNumber nt (toInteger (fromIntegral i :: Word32))
   LitNumInt64   -> LitNumber nt (toInteger (fromIntegral i :: Int64))
   LitNumWord64  -> LitNumber nt (toInteger (fromIntegral i :: Word64))
   LitNumInteger -> v
@@ -305,7 +329,13 @@ litNumCheckRange :: Platform -> LitNumType -> Integer -> Bool
 litNumCheckRange platform nt i = case nt of
      LitNumInt     -> platformInIntRange platform i
      LitNumWord    -> platformInWordRange platform i
+     LitNumInt8    -> inInt8Range i
+     LitNumInt16   -> inInt16Range i
+     LitNumInt32   -> inInt32Range i
      LitNumInt64   -> inInt64Range i
+     LitNumWord8   -> inWord8Range i
+     LitNumWord16  -> inWord16Range i
+     LitNumWord32  -> inWord32Range i
      LitNumWord64  -> inWord64Range i
      LitNumNatural -> i >= 0
      LitNumInteger -> True
@@ -364,6 +394,84 @@ mkLitWordWrapC platform i = (n, i /= i')
   where
     n@(LitNumber _ i') = mkLitWordWrap platform i
 
+-- | Creates a 'Literal' of type @Int8#@
+mkLitInt8 :: Integer -> Literal
+mkLitInt8  x = ASSERT2( inInt8Range x, integer x ) (mkLitInt8Unchecked x)
+
+-- | Creates a 'Literal' of type @Int8#@.
+--   If the argument is out of the range, it is wrapped.
+mkLitInt8Wrap :: Platform -> Integer -> Literal
+mkLitInt8Wrap platform i = wrapLitNumber platform $ mkLitInt8Unchecked i
+
+-- | Creates a 'Literal' of type @Int8#@ without checking its range.
+mkLitInt8Unchecked :: Integer -> Literal
+mkLitInt8Unchecked i = LitNumber LitNumInt8 i
+
+-- | Creates a 'Literal' of type @Word8#@
+mkLitWord8 :: Integer -> Literal
+mkLitWord8 x = ASSERT2( inWord8Range x, integer x ) (mkLitWord8Unchecked x)
+
+-- | Creates a 'Literal' of type @Word8#@.
+--   If the argument is out of the range, it is wrapped.
+mkLitWord8Wrap :: Platform -> Integer -> Literal
+mkLitWord8Wrap platform i = wrapLitNumber platform $ mkLitWord8Unchecked i
+
+-- | Creates a 'Literal' of type @Word8#@ without checking its range.
+mkLitWord8Unchecked :: Integer -> Literal
+mkLitWord8Unchecked i = LitNumber LitNumWord8 i
+
+-- | Creates a 'Literal' of type @Int16#@
+mkLitInt16 :: Integer -> Literal
+mkLitInt16  x = ASSERT2( inInt16Range x, integer x ) (mkLitInt16Unchecked x)
+
+-- | Creates a 'Literal' of type @Int16#@.
+--   If the argument is out of the range, it is wrapped.
+mkLitInt16Wrap :: Platform -> Integer -> Literal
+mkLitInt16Wrap platform i = wrapLitNumber platform $ mkLitInt16Unchecked i
+
+-- | Creates a 'Literal' of type @Int16#@ without checking its range.
+mkLitInt16Unchecked :: Integer -> Literal
+mkLitInt16Unchecked i = LitNumber LitNumInt16 i
+
+-- | Creates a 'Literal' of type @Word16#@
+mkLitWord16 :: Integer -> Literal
+mkLitWord16 x = ASSERT2( inWord16Range x, integer x ) (mkLitWord16Unchecked x)
+
+-- | Creates a 'Literal' of type @Word16#@.
+--   If the argument is out of the range, it is wrapped.
+mkLitWord16Wrap :: Platform -> Integer -> Literal
+mkLitWord16Wrap platform i = wrapLitNumber platform $ mkLitWord16Unchecked i
+
+-- | Creates a 'Literal' of type @Word16#@ without checking its range.
+mkLitWord16Unchecked :: Integer -> Literal
+mkLitWord16Unchecked i = LitNumber LitNumWord16 i
+
+-- | Creates a 'Literal' of type @Int32#@
+mkLitInt32 :: Integer -> Literal
+mkLitInt32  x = ASSERT2( inInt32Range x, integer x ) (mkLitInt32Unchecked x)
+
+-- | Creates a 'Literal' of type @Int32#@.
+--   If the argument is out of the range, it is wrapped.
+mkLitInt32Wrap :: Platform -> Integer -> Literal
+mkLitInt32Wrap platform i = wrapLitNumber platform $ mkLitInt32Unchecked i
+
+-- | Creates a 'Literal' of type @Int32#@ without checking its range.
+mkLitInt32Unchecked :: Integer -> Literal
+mkLitInt32Unchecked i = LitNumber LitNumInt32 i
+
+-- | Creates a 'Literal' of type @Word32#@
+mkLitWord32 :: Integer -> Literal
+mkLitWord32 x = ASSERT2( inWord32Range x, integer x ) (mkLitWord32Unchecked x)
+
+-- | Creates a 'Literal' of type @Word32#@.
+--   If the argument is out of the range, it is wrapped.
+mkLitWord32Wrap :: Platform -> Integer -> Literal
+mkLitWord32Wrap platform i = wrapLitNumber platform $ mkLitWord32Unchecked i
+
+-- | Creates a 'Literal' of type @Word32#@ without checking its range.
+mkLitWord32Unchecked :: Integer -> Literal
+mkLitWord32Unchecked i = LitNumber LitNumWord32 i
+
 -- | Creates a 'Literal' of type @Int64#@
 mkLitInt64 :: Integer -> Literal
 mkLitInt64  x = ASSERT2( inInt64Range x, integer x ) (mkLitInt64Unchecked x)
@@ -418,7 +526,20 @@ mkLitNatural x = ASSERT2( inNaturalRange x,  integer x )
 inNaturalRange :: Integer -> Bool
 inNaturalRange x = x >= 0
 
-inInt64Range, inWord64Range :: Integer -> Bool
+inInt8Range,  inWord8Range,  inInt16Range, inWord16Range :: Integer -> Bool
+inInt32Range, inWord32Range, inInt64Range, inWord64Range :: Integer -> Bool
+inInt8Range  x  = x >= toInteger (minBound :: Int8) &&
+                  x <= toInteger (maxBound :: Int8)
+inWord8Range  x = x >= toInteger (minBound :: Word8) &&
+                  x <= toInteger (maxBound :: Word8)
+inInt16Range x  = x >= toInteger (minBound :: Int16) &&
+                  x <= toInteger (maxBound :: Int16)
+inWord16Range x = x >= toInteger (minBound :: Word16) &&
+                  x <= toInteger (maxBound :: Word16)
+inInt32Range x  = x >= toInteger (minBound :: Int32) &&
+                  x <= toInteger (maxBound :: Int32)
+inWord32Range x = x >= toInteger (minBound :: Word32) &&
+                  x <= toInteger (maxBound :: Word32)
 inInt64Range x  = x >= toInteger (minBound :: Int64) &&
                   x <= toInteger (maxBound :: Int64)
 inWord64Range x = x >= toInteger (minBound :: Word64) &&
@@ -572,8 +693,14 @@ litIsTrivial (LitNumber nt _) = case nt of
   LitNumInteger -> False
   LitNumNatural -> False
   LitNumInt     -> True
+  LitNumInt8    -> True
+  LitNumInt16   -> True
+  LitNumInt32   -> True
   LitNumInt64   -> True
   LitNumWord    -> True
+  LitNumWord8   -> True
+  LitNumWord16  -> True
+  LitNumWord32  -> True
   LitNumWord64  -> True
 litIsTrivial _                  = True
 
@@ -585,8 +712,14 @@ litIsDupable platform x = case x of
       LitNumInteger -> platformInIntRange platform i
       LitNumNatural -> platformInWordRange platform i
       LitNumInt     -> True
+      LitNumInt8    -> True
+      LitNumInt16   -> True
+      LitNumInt32   -> True
       LitNumInt64   -> True
       LitNumWord    -> True
+      LitNumWord8   -> True
+      LitNumWord16  -> True
+      LitNumWord32  -> True
       LitNumWord64  -> True
    (LitString _) -> False
    _             -> True
@@ -601,8 +734,14 @@ litIsLifted (LitNumber nt _) = case nt of
   LitNumInteger -> True
   LitNumNatural -> True
   LitNumInt     -> False
+  LitNumInt8    -> False
+  LitNumInt16   -> False
+  LitNumInt32   -> False
   LitNumInt64   -> False
   LitNumWord    -> False
+  LitNumWord8   -> False
+  LitNumWord16  -> False
+  LitNumWord32  -> False
   LitNumWord64  -> False
 litIsLifted _                  = False
 
@@ -623,8 +762,14 @@ literalType (LitNumber lt _)  = case lt of
    LitNumInteger -> integerTy
    LitNumNatural -> naturalTy
    LitNumInt     -> intPrimTy
+   LitNumInt8    -> int8PrimTy
+   LitNumInt16   -> int16PrimTy
+   LitNumInt32   -> int32PrimTy
    LitNumInt64   -> int64PrimTy
    LitNumWord    -> wordPrimTy
+   LitNumWord8   -> word8PrimTy
+   LitNumWord16  -> word16PrimTy
+   LitNumWord32  -> word32PrimTy
    LitNumWord64  -> word64PrimTy
 literalType (LitRubbish)      = mkForAllTy a Inferred (mkTyVarTy a)
   where
@@ -700,8 +845,14 @@ pprLiteral add_par (LitNumber nt i)
        LitNumInteger -> pprIntegerVal add_par i
        LitNumNatural -> pprIntegerVal add_par i
        LitNumInt     -> pprPrimInt i
+       LitNumInt8    -> pprPrimInt8 i
+       LitNumInt16   -> pprPrimInt16 i
+       LitNumInt32   -> pprPrimInt32 i
        LitNumInt64   -> pprPrimInt64 i
        LitNumWord    -> pprPrimWord i
+       LitNumWord8   -> pprPrimWord8 i
+       LitNumWord16  -> pprPrimWord16 i
+       LitNumWord32  -> pprPrimWord32 i
        LitNumWord64  -> pprPrimWord64 i
 pprLiteral add_par (LitLabel l mb fod) =
     add_par (text "__label" <+> b <+> ppr fod)
diff --git a/compiler/GHC/Utils/Outputable.hs b/compiler/GHC/Utils/Outputable.hs
index 16e66ce6d1..decf70d990 100644
--- a/compiler/GHC/Utils/Outputable.hs
+++ b/compiler/GHC/Utils/Outputable.hs
@@ -61,7 +61,9 @@ module GHC.Utils.Outputable (
         primFloatSuffix, primCharSuffix, primWordSuffix, primDoubleSuffix,
         primInt64Suffix, primWord64Suffix, primIntSuffix,
 
-        pprPrimChar, pprPrimInt, pprPrimWord, pprPrimInt64, pprPrimWord64,
+        pprPrimChar, pprPrimInt, pprPrimWord,
+        pprPrimInt8, pprPrimInt16, pprPrimInt32, pprPrimInt64,
+        pprPrimWord8, pprPrimWord16, pprPrimWord32, pprPrimWord64,
 
         pprFastFilePath, pprFilePathString,
 
@@ -1158,11 +1160,19 @@ primWord64Suffix = text "L##"
 
 -- | Special combinator for showing unboxed literals.
 pprPrimChar :: Char -> SDoc
-pprPrimInt, pprPrimWord, pprPrimInt64, pprPrimWord64 :: Integer -> SDoc
+pprPrimInt, pprPrimWord :: Integer -> SDoc
+pprPrimInt8, pprPrimInt16, pprPrimInt32, pprPrimInt64 :: Integer -> SDoc
+pprPrimWord8, pprPrimWord16, pprPrimWord32, pprPrimWord64 :: Integer -> SDoc
 pprPrimChar c   = pprHsChar c <> primCharSuffix
 pprPrimInt i    = integer i   <> primIntSuffix
 pprPrimWord w   = word    w   <> primWordSuffix
+pprPrimInt8 i   = integer i   <> primInt64Suffix
+pprPrimInt16 i  = integer i   <> primInt64Suffix
+pprPrimInt32 i  = integer i   <> primInt64Suffix
 pprPrimInt64 i  = integer i   <> primInt64Suffix
+pprPrimWord8 w  = word    w   <> primWord64Suffix
+pprPrimWord16 w = word    w   <> primWord64Suffix
+pprPrimWord32 w = word    w   <> primWord64Suffix
 pprPrimWord64 w = word    w   <> primWord64Suffix
 
 ---------------------
diff --git a/testsuite/tests/parser/should_run/BinaryLiterals2.hs b/testsuite/tests/parser/should_run/BinaryLiterals2.hs
index 3779d52341..305a12cab3 100644
--- a/testsuite/tests/parser/should_run/BinaryLiterals2.hs
+++ b/testsuite/tests/parser/should_run/BinaryLiterals2.hs
@@ -6,6 +6,7 @@
 
 module Main where
 
+import GHC.Base
 import GHC.Types
 import GHC.Int
 
@@ -26,4 +27,4 @@ main = do
           , -0B11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
           ]
 
-    print [ I8# -0B10000000#, I8# 0B1111111# ]
+    print [ I8# (narrowInt8# -0B10000000#), I8# (narrowInt8# 0B1111111#) ]