module Literal
(
Literal(..)
, LitNumType(..)
, mkMachInt, mkMachIntWrap, mkMachIntWrapC
, mkMachWord, mkMachWordWrap, mkMachWordWrapC
, mkMachInt64, mkMachInt64Wrap
, mkMachWord64, mkMachWord64Wrap
, mkMachFloat, mkMachDouble
, mkMachChar, mkMachString
, mkLitInteger, mkLitNatural
, mkLitNumber, mkLitNumberWrap
, literalType
, absentLiteralOf
, pprLiteral
, litNumIsSigned
, litNumCheckRange
, litIsDupable, litIsTrivial, litIsLifted
, inIntRange, inWordRange, tARGET_MAX_INT, inCharRange
, isZeroLit
, litFitsInChar
, litValue, isLitValue, isLitValue_maybe, mapLitValue
, word2IntLit, int2WordLit
, narrowLit
, narrow8IntLit, narrow16IntLit, narrow32IntLit
, narrow8WordLit, narrow16WordLit, narrow32WordLit
, char2IntLit, int2CharLit
, float2IntLit, int2FloatLit, double2IntLit, int2DoubleLit
, nullAddrLit, float2DoubleLit, double2FloatLit
) where
#include "HsVersions.h"
import GhcPrelude
import TysPrim
import PrelNames
import Type
import TyCon
import Outputable
import FastString
import BasicTypes
import Binary
import Constants
import DynFlags
import Platform
import UniqFM
import Util
import Data.ByteString (ByteString)
import Data.Int
import Data.Word
import Data.Char
import Data.Maybe ( isJust )
import Data.Data ( Data )
import Data.Proxy
import Numeric ( fromRat )
data Literal
=
MachChar Char
| LitNumber !LitNumType !Integer Type
| MachStr ByteString
| MachNullAddr
| MachFloat Rational
| MachDouble Rational
| MachLabel FastString
(Maybe Int)
FunctionOrData
deriving Data
data LitNumType
= LitNumInteger
| LitNumNatural
| LitNumInt
| LitNumInt64
| LitNumWord
| LitNumWord64
deriving (Data,Enum,Eq,Ord)
litNumIsSigned :: LitNumType -> Bool
litNumIsSigned nt = case nt of
LitNumInteger -> True
LitNumNatural -> False
LitNumInt -> True
LitNumInt64 -> True
LitNumWord -> False
LitNumWord64 -> False
instance Binary LitNumType where
put_ bh numTyp = putByte bh (fromIntegral (fromEnum numTyp))
get bh = do
h <- getByte bh
return (toEnum (fromIntegral h))
instance Binary Literal where
put_ bh (MachChar aa) = do putByte bh 0; put_ bh aa
put_ bh (MachStr ab) = do putByte bh 1; put_ bh ab
put_ bh (MachNullAddr) = do putByte bh 2
put_ bh (MachFloat ah) = do putByte bh 3; put_ bh ah
put_ bh (MachDouble ai) = do putByte bh 4; put_ bh ai
put_ bh (MachLabel aj mb fod)
= do putByte bh 5
put_ bh aj
put_ bh mb
put_ bh fod
put_ bh (LitNumber nt i _)
= do putByte bh 6
put_ bh nt
put_ bh i
get bh = do
h <- getByte bh
case h of
0 -> do
aa <- get bh
return (MachChar aa)
1 -> do
ab <- get bh
return (MachStr ab)
2 -> do
return (MachNullAddr)
3 -> do
ah <- get bh
return (MachFloat ah)
4 -> do
ai <- get bh
return (MachDouble ai)
5 -> do
aj <- get bh
mb <- get bh
fod <- get bh
return (MachLabel aj mb fod)
_ -> do
nt <- get bh
i <- get bh
let t = case nt of
LitNumInt -> intPrimTy
LitNumInt64 -> int64PrimTy
LitNumWord -> wordPrimTy
LitNumWord64 -> word64PrimTy
LitNumInteger ->
panic "Evaluated the place holder for mkInteger"
LitNumNatural ->
panic "Evaluated the place holder for mkNatural"
return (LitNumber nt i t)
instance Outputable Literal where
ppr lit = pprLiteral (\d -> d) lit
instance Eq Literal where
a == b = case (a `compare` b) of { EQ -> True; _ -> False }
a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
instance Ord Literal where
a <= b = case (a `compare` b) of { LT -> True; EQ -> True; GT -> False }
a < b = case (a `compare` b) of { LT -> True; EQ -> False; GT -> False }
a >= b = case (a `compare` b) of { LT -> False; EQ -> True; GT -> True }
a > b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True }
compare a b = cmpLit a b
wrapLitNumber :: DynFlags -> Literal -> Literal
wrapLitNumber dflags v@(LitNumber nt i t) = case nt of
LitNumInt -> case platformWordSize (targetPlatform dflags) of
4 -> LitNumber nt (toInteger (fromIntegral i :: Int32)) t
8 -> LitNumber nt (toInteger (fromIntegral i :: Int64)) t
w -> panic ("wrapLitNumber: Unknown platformWordSize: " ++ show w)
LitNumWord -> case platformWordSize (targetPlatform dflags) of
4 -> LitNumber nt (toInteger (fromIntegral i :: Word32)) t
8 -> LitNumber nt (toInteger (fromIntegral i :: Word64)) t
w -> panic ("wrapLitNumber: Unknown platformWordSize: " ++ show w)
LitNumInt64 -> LitNumber nt (toInteger (fromIntegral i :: Int64)) t
LitNumWord64 -> LitNumber nt (toInteger (fromIntegral i :: Word64)) t
LitNumInteger -> v
LitNumNatural -> v
wrapLitNumber _ x = x
mkLitNumberWrap :: DynFlags -> LitNumType -> Integer -> Type -> Literal
mkLitNumberWrap dflags nt i t = wrapLitNumber dflags (LitNumber nt i t)
litNumCheckRange :: DynFlags -> LitNumType -> Integer -> Bool
litNumCheckRange dflags nt i = case nt of
LitNumInt -> inIntRange dflags i
LitNumWord -> inWordRange dflags i
LitNumInt64 -> inInt64Range i
LitNumWord64 -> inWord64Range i
LitNumNatural -> i >= 0
LitNumInteger -> True
mkLitNumber :: DynFlags -> LitNumType -> Integer -> Type -> Literal
mkLitNumber dflags nt i t =
ASSERT2(litNumCheckRange dflags nt i, integer i)
(LitNumber nt i t)
mkMachInt :: DynFlags -> Integer -> Literal
mkMachInt dflags x = ASSERT2( inIntRange dflags x, integer x )
(mkMachIntUnchecked x)
mkMachIntWrap :: DynFlags -> Integer -> Literal
mkMachIntWrap dflags i = wrapLitNumber dflags $ mkMachIntUnchecked i
mkMachIntUnchecked :: Integer -> Literal
mkMachIntUnchecked i = LitNumber LitNumInt i intPrimTy
mkMachIntWrapC :: DynFlags -> Integer -> (Literal, Bool)
mkMachIntWrapC dflags i = (n, i /= i')
where
n@(LitNumber _ i' _) = mkMachIntWrap dflags i
mkMachWord :: DynFlags -> Integer -> Literal
mkMachWord dflags x = ASSERT2( inWordRange dflags x, integer x )
(mkMachWordUnchecked x)
mkMachWordWrap :: DynFlags -> Integer -> Literal
mkMachWordWrap dflags i = wrapLitNumber dflags $ mkMachWordUnchecked i
mkMachWordUnchecked :: Integer -> Literal
mkMachWordUnchecked i = LitNumber LitNumWord i wordPrimTy
mkMachWordWrapC :: DynFlags -> Integer -> (Literal, Bool)
mkMachWordWrapC dflags i = (n, i /= i')
where
n@(LitNumber _ i' _) = mkMachWordWrap dflags i
mkMachInt64 :: Integer -> Literal
mkMachInt64 x = ASSERT2( inInt64Range x, integer x ) (mkMachInt64Unchecked x)
mkMachInt64Wrap :: DynFlags -> Integer -> Literal
mkMachInt64Wrap dflags i = wrapLitNumber dflags $ mkMachInt64Unchecked i
mkMachInt64Unchecked :: Integer -> Literal
mkMachInt64Unchecked i = LitNumber LitNumInt64 i int64PrimTy
mkMachWord64 :: Integer -> Literal
mkMachWord64 x = ASSERT2( inWord64Range x, integer x ) (mkMachWord64Unchecked x)
mkMachWord64Wrap :: DynFlags -> Integer -> Literal
mkMachWord64Wrap dflags i = wrapLitNumber dflags $ mkMachWord64Unchecked i
mkMachWord64Unchecked :: Integer -> Literal
mkMachWord64Unchecked i = LitNumber LitNumWord64 i word64PrimTy
mkMachFloat :: Rational -> Literal
mkMachFloat = MachFloat
mkMachDouble :: Rational -> Literal
mkMachDouble = MachDouble
mkMachChar :: Char -> Literal
mkMachChar = MachChar
mkMachString :: String -> Literal
mkMachString s = MachStr (fastStringToByteString $ mkFastString s)
mkLitInteger :: Integer -> Type -> Literal
mkLitInteger x ty = LitNumber LitNumInteger x ty
mkLitNatural :: Integer -> Type -> Literal
mkLitNatural x ty = ASSERT2( inNaturalRange x, integer x )
(LitNumber LitNumNatural x ty)
inIntRange, inWordRange :: DynFlags -> Integer -> Bool
inIntRange dflags x = x >= tARGET_MIN_INT dflags && x <= tARGET_MAX_INT dflags
inWordRange dflags x = x >= 0 && x <= tARGET_MAX_WORD dflags
inNaturalRange :: Integer -> Bool
inNaturalRange x = x >= 0
inInt64Range, inWord64Range :: Integer -> Bool
inInt64Range x = x >= toInteger (minBound :: Int64) &&
x <= toInteger (maxBound :: Int64)
inWord64Range x = x >= toInteger (minBound :: Word64) &&
x <= toInteger (maxBound :: Word64)
inCharRange :: Char -> Bool
inCharRange c = c >= '\0' && c <= chr tARGET_MAX_CHAR
isZeroLit :: Literal -> Bool
isZeroLit (LitNumber _ 0 _) = True
isZeroLit (MachFloat 0) = True
isZeroLit (MachDouble 0) = True
isZeroLit _ = False
litValue :: Literal -> Integer
litValue l = case isLitValue_maybe l of
Just x -> x
Nothing -> pprPanic "litValue" (ppr l)
isLitValue_maybe :: Literal -> Maybe Integer
isLitValue_maybe (MachChar c) = Just $ toInteger $ ord c
isLitValue_maybe (LitNumber _ i _) = Just i
isLitValue_maybe _ = Nothing
mapLitValue :: DynFlags -> (Integer -> Integer) -> Literal -> Literal
mapLitValue _ f (MachChar c) = mkMachChar (fchar c)
where fchar = chr . fromInteger . f . toInteger . ord
mapLitValue dflags f (LitNumber nt i t) = wrapLitNumber dflags
(LitNumber nt (f i) t)
mapLitValue _ _ l = pprPanic "mapLitValue" (ppr l)
isLitValue :: Literal -> Bool
isLitValue = isJust . isLitValue_maybe
narrow8IntLit, narrow16IntLit, narrow32IntLit,
narrow8WordLit, narrow16WordLit, narrow32WordLit,
char2IntLit, int2CharLit,
float2IntLit, int2FloatLit, double2IntLit, int2DoubleLit,
float2DoubleLit, double2FloatLit
:: Literal -> Literal
word2IntLit, int2WordLit :: DynFlags -> Literal -> Literal
word2IntLit dflags (LitNumber LitNumWord w _)
| w > tARGET_MAX_INT dflags = mkMachInt dflags (w tARGET_MAX_WORD dflags 1)
| otherwise = mkMachInt dflags w
word2IntLit _ l = pprPanic "word2IntLit" (ppr l)
int2WordLit dflags (LitNumber LitNumInt i _)
| i < 0 = mkMachWord dflags (1 + tARGET_MAX_WORD dflags + i)
| otherwise = mkMachWord dflags i
int2WordLit _ l = pprPanic "int2WordLit" (ppr l)
narrowLit :: forall a. Integral a => Proxy a -> Literal -> Literal
narrowLit _ (LitNumber nt i t) = LitNumber nt (toInteger (fromInteger i :: a)) t
narrowLit _ l = pprPanic "narrowLit" (ppr l)
narrow8IntLit = narrowLit (Proxy :: Proxy Int8)
narrow16IntLit = narrowLit (Proxy :: Proxy Int16)
narrow32IntLit = narrowLit (Proxy :: Proxy Int32)
narrow8WordLit = narrowLit (Proxy :: Proxy Word8)
narrow16WordLit = narrowLit (Proxy :: Proxy Word16)
narrow32WordLit = narrowLit (Proxy :: Proxy Word32)
char2IntLit (MachChar c) = mkMachIntUnchecked (toInteger (ord c))
char2IntLit l = pprPanic "char2IntLit" (ppr l)
int2CharLit (LitNumber _ i _) = MachChar (chr (fromInteger i))
int2CharLit l = pprPanic "int2CharLit" (ppr l)
float2IntLit (MachFloat f) = mkMachIntUnchecked (truncate f)
float2IntLit l = pprPanic "float2IntLit" (ppr l)
int2FloatLit (LitNumber _ i _) = MachFloat (fromInteger i)
int2FloatLit l = pprPanic "int2FloatLit" (ppr l)
double2IntLit (MachDouble f) = mkMachIntUnchecked (truncate f)
double2IntLit l = pprPanic "double2IntLit" (ppr l)
int2DoubleLit (LitNumber _ i _) = MachDouble (fromInteger i)
int2DoubleLit l = pprPanic "int2DoubleLit" (ppr l)
float2DoubleLit (MachFloat f) = MachDouble f
float2DoubleLit l = pprPanic "float2DoubleLit" (ppr l)
double2FloatLit (MachDouble d) = MachFloat d
double2FloatLit l = pprPanic "double2FloatLit" (ppr l)
nullAddrLit :: Literal
nullAddrLit = MachNullAddr
litIsTrivial :: Literal -> Bool
litIsTrivial (MachStr _) = False
litIsTrivial (LitNumber nt _ _) = case nt of
LitNumInteger -> False
LitNumNatural -> False
LitNumInt -> True
LitNumInt64 -> True
LitNumWord -> True
LitNumWord64 -> True
litIsTrivial _ = True
litIsDupable :: DynFlags -> Literal -> Bool
litIsDupable _ (MachStr _) = False
litIsDupable dflags (LitNumber nt i _) = case nt of
LitNumInteger -> inIntRange dflags i
LitNumNatural -> inIntRange dflags i
LitNumInt -> True
LitNumInt64 -> True
LitNumWord -> True
LitNumWord64 -> True
litIsDupable _ _ = True
litFitsInChar :: Literal -> Bool
litFitsInChar (LitNumber _ i _) = i >= toInteger (ord minBound)
&& i <= toInteger (ord maxBound)
litFitsInChar _ = False
litIsLifted :: Literal -> Bool
litIsLifted (LitNumber nt _ _) = case nt of
LitNumInteger -> True
LitNumNatural -> True
LitNumInt -> False
LitNumInt64 -> False
LitNumWord -> False
LitNumWord64 -> False
litIsLifted _ = False
literalType :: Literal -> Type
literalType MachNullAddr = addrPrimTy
literalType (MachChar _) = charPrimTy
literalType (MachStr _) = addrPrimTy
literalType (MachFloat _) = floatPrimTy
literalType (MachDouble _) = doublePrimTy
literalType (MachLabel _ _ _) = addrPrimTy
literalType (LitNumber _ _ t) = t
absentLiteralOf :: TyCon -> Maybe Literal
absentLiteralOf tc = lookupUFM absent_lits (tyConName tc)
absent_lits :: UniqFM Literal
absent_lits = listToUFM [ (addrPrimTyConKey, MachNullAddr)
, (charPrimTyConKey, MachChar 'x')
, (intPrimTyConKey, mkMachIntUnchecked 0)
, (int64PrimTyConKey, mkMachInt64Unchecked 0)
, (wordPrimTyConKey, mkMachWordUnchecked 0)
, (word64PrimTyConKey, mkMachWord64Unchecked 0)
, (floatPrimTyConKey, MachFloat 0)
, (doublePrimTyConKey, MachDouble 0)
]
cmpLit :: Literal -> Literal -> Ordering
cmpLit (MachChar a) (MachChar b) = a `compare` b
cmpLit (MachStr a) (MachStr b) = a `compare` b
cmpLit (MachNullAddr) (MachNullAddr) = EQ
cmpLit (MachFloat a) (MachFloat b) = a `compare` b
cmpLit (MachDouble a) (MachDouble b) = a `compare` b
cmpLit (MachLabel a _ _) (MachLabel b _ _) = a `compare` b
cmpLit (LitNumber nt1 a _) (LitNumber nt2 b _)
| nt1 == nt2 = a `compare` b
| otherwise = nt1 `compare` nt2
cmpLit lit1 lit2
| litTag lit1 < litTag lit2 = LT
| otherwise = GT
litTag :: Literal -> Int
litTag (MachChar _) = 1
litTag (MachStr _) = 2
litTag (MachNullAddr) = 3
litTag (MachFloat _) = 4
litTag (MachDouble _) = 5
litTag (MachLabel _ _ _) = 6
litTag (LitNumber {}) = 7
pprLiteral :: (SDoc -> SDoc) -> Literal -> SDoc
pprLiteral _ (MachChar c) = pprPrimChar c
pprLiteral _ (MachStr s) = pprHsBytes s
pprLiteral _ (MachNullAddr) = text "__NULL"
pprLiteral _ (MachFloat f) = float (fromRat f) <> primFloatSuffix
pprLiteral _ (MachDouble d) = double (fromRat d) <> primDoubleSuffix
pprLiteral add_par (LitNumber nt i _)
= case nt of
LitNumInteger -> pprIntegerVal add_par i
LitNumNatural -> pprIntegerVal add_par i
LitNumInt -> pprPrimInt i
LitNumInt64 -> pprPrimInt64 i
LitNumWord -> pprPrimWord i
LitNumWord64 -> pprPrimWord64 i
pprLiteral add_par (MachLabel l mb fod) = add_par (text "__label" <+> b <+> ppr fod)
where b = case mb of
Nothing -> pprHsString l
Just x -> doubleQuotes (text (unpackFS l ++ '@':show x))
pprIntegerVal :: (SDoc -> SDoc) -> Integer -> SDoc
pprIntegerVal add_par i | i < 0 = add_par (integer i)
| otherwise = integer i