Type.hs 14.1 KB
Newer Older
1
module GHC.Cmm.Type
2
    ( CmmType   -- Abstract
3
    , b8, b16, b32, b64, b128, b256, b512, f32, f64, bWord, bHalfWord, gcWord
4
    , cInt
5 6
    , cmmBits, cmmFloat
    , typeWidth, cmmEqType, cmmEqType_ignoring_ptrhood
7
    , isFloatType, isGcPtrType, isBitsType
8 9
    , isWordAny, isWord32, isWord64
    , isFloat64, isFloat32
10 11 12

    , Width(..)
    , widthInBits, widthInBytes, widthInLog, widthFromBytes
13
    , wordWidth, halfWordWidth, cIntWidth
Ian Lynagh's avatar
Ian Lynagh committed
14
    , halfWordMask
15
    , narrowU, narrowS
16 17 18
    , rEP_CostCentreStack_mem_alloc
    , rEP_CostCentreStack_scc_count
    , rEP_StgEntCounter_allocs
nfrisby's avatar
nfrisby committed
19
    , rEP_StgEntCounter_allocd
20 21

    , ForeignHint(..)
22 23 24 25 26 27 28

    , Length
    , vec, vec2, vec4, vec8, vec16
    , vec2f64, vec2b64, vec4f32, vec4b32, vec8b16, vec16b8
    , cmmVec
    , vecLength, vecElemType
    , isVecType
29 30 31 32
   )
where


33
import GHC.Prelude
34

35
import GHC.Platform
36 37
import GHC.Data.FastString
import GHC.Utils.Outputable
38
import GHC.Utils.Panic
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

import Data.Word
import Data.Int

-----------------------------------------------------------------------------
--              CmmType
-----------------------------------------------------------------------------

  -- NOTE: CmmType is an abstract type, not exported from this
  --       module so you can easily change its representation
  --
  -- However Width is exported in a concrete way,
  -- and is used extensively in pattern-matching

data CmmType    -- The important one!
54
  = CmmType CmmCat !Width
55

56 57 58 59 60
data CmmCat                -- "Category" (not exported)
   = GcPtrCat              -- GC pointer
   | BitsCat               -- Non-pointer
   | FloatCat              -- Float
   | VecCat Length CmmCat  -- Vector
61 62 63 64 65 66 67
   deriving( Eq )
        -- See Note [Signed vs unsigned] at the end

instance Outputable CmmType where
  ppr (CmmType cat wid) = ppr cat <> ppr (widthInBits wid)

instance Outputable CmmCat where
68 69 70
  ppr FloatCat       = text "F"
  ppr GcPtrCat       = text "P"
  ppr BitsCat        = text "I"
71
  ppr (VecCat n cat) = ppr cat <> text "x" <> ppr n <> text "V"
72 73 74 75

-- Why is CmmType stratified?  For native code generation,
-- most of the time you just want to know what sort of register
-- to put the thing in, and for this you need to know how
76
-- many bits thing has, and whether it goes in a floating-point
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
-- register.  By contrast, the distinction between GcPtr and
-- GcNonPtr is of interest to only a few parts of the code generator.

-------- Equality on CmmType --------------
-- CmmType is *not* an instance of Eq; sometimes we care about the
-- Gc/NonGc distinction, and sometimes we don't
-- So we use an explicit function to force you to think about it
cmmEqType :: CmmType -> CmmType -> Bool -- Exact equality
cmmEqType (CmmType c1 w1) (CmmType c2 w2) = c1==c2 && w1==w2

cmmEqType_ignoring_ptrhood :: CmmType -> CmmType -> Bool
  -- This equality is temporary; used in CmmLint
  -- but the RTS files are not yet well-typed wrt pointers
cmmEqType_ignoring_ptrhood (CmmType c1 w1) (CmmType c2 w2)
   = c1 `weak_eq` c2 && w1==w2
   where
93 94 95 96 97 98 99 100 101
     weak_eq :: CmmCat -> CmmCat -> Bool
     FloatCat         `weak_eq` FloatCat         = True
     FloatCat         `weak_eq` _other           = False
     _other           `weak_eq` FloatCat         = False
     (VecCat l1 cat1) `weak_eq` (VecCat l2 cat2) = l1 == l2
                                                   && cat1 `weak_eq` cat2
     (VecCat {})      `weak_eq` _other           = False
     _other           `weak_eq` (VecCat {})      = False
     _word1           `weak_eq` _word2           = True        -- Ignores GcPtr
102 103 104 105 106 107 108 109 110 111 112

--- Simple operations on CmmType -----
typeWidth :: CmmType -> Width
typeWidth (CmmType _ w) = w

cmmBits, cmmFloat :: Width -> CmmType
cmmBits  = CmmType BitsCat
cmmFloat = CmmType FloatCat

-------- Common CmmTypes ------------
-- Floats and words of specific widths
113
b8, b16, b32, b64, b128, b256, b512, f32, f64 :: CmmType
114 115 116 117
b8     = cmmBits W8
b16    = cmmBits W16
b32    = cmmBits W32
b64    = cmmBits W64
118
b128   = cmmBits W128
119
b256   = cmmBits W256
120
b512   = cmmBits W512
121 122 123 124
f32    = cmmFloat W32
f64    = cmmFloat W64

-- CmmTypes of native word widths
125 126
bWord :: Platform -> CmmType
bWord platform = cmmBits (wordWidth platform)
127

128 129
bHalfWord :: Platform -> CmmType
bHalfWord platform = cmmBits (halfWordWidth platform)
130

131 132
gcWord :: Platform -> CmmType
gcWord platform = CmmType GcPtrCat (wordWidth platform)
133

134 135
cInt :: Platform -> CmmType
cInt platform = cmmBits (cIntWidth platform)
136 137

------------ Predicates ----------------
138
isFloatType, isGcPtrType, isBitsType :: CmmType -> Bool
139 140 141 142 143
isFloatType (CmmType FloatCat    _) = True
isFloatType _other                  = False

isGcPtrType (CmmType GcPtrCat _) = True
isGcPtrType _other               = False
144 145 146

isBitsType (CmmType BitsCat _) = True
isBitsType _                   = False
147

148 149
isWordAny, isWord32, isWord64,
  isFloat32, isFloat64 :: CmmType -> Bool
150 151 152
-- isWord64 is true of 64-bit non-floats (both gc-ptrs and otherwise)
-- isFloat32 and 64 are obvious

153 154 155 156
isWordAny (CmmType BitsCat  _) = True
isWordAny (CmmType GcPtrCat _) = True
isWordAny _other               = False

157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
isWord64 (CmmType BitsCat  W64) = True
isWord64 (CmmType GcPtrCat W64) = True
isWord64 _other                 = False

isWord32 (CmmType BitsCat  W32) = True
isWord32 (CmmType GcPtrCat W32) = True
isWord32 _other                 = False

isFloat32 (CmmType FloatCat W32) = True
isFloat32 _other                 = False

isFloat64 (CmmType FloatCat W64) = True
isFloat64 _other                 = False

-----------------------------------------------------------------------------
--              Width
-----------------------------------------------------------------------------

data Width   = W8 | W16 | W32 | W64
             | W128
177
             | W256
178
             | W512
179 180 181 182 183
             deriving (Eq, Ord, Show)

instance Outputable Width where
   ppr rep = ptext (mrStr rep)

Sylvain Henry's avatar
Sylvain Henry committed
184
mrStr :: Width -> PtrString
Gabor Greif's avatar
Gabor Greif committed
185
mrStr = sLit . show
186 187 188


-------- Common Widths  ------------
189 190 191 192 193 194 195 196 197 198 199 200 201 202
wordWidth :: Platform -> Width
wordWidth platform = case platformWordSize platform of
 PW4 -> W32
 PW8 -> W64

halfWordWidth :: Platform -> Width
halfWordWidth platform = case platformWordSize platform of
 PW4 -> W16
 PW8 -> W32

halfWordMask :: Platform -> Integer
halfWordMask platform = case platformWordSize platform of
 PW4 -> 0xFFFF
 PW8 -> 0xFFFFFFFF
Ian Lynagh's avatar
Ian Lynagh committed
203

204
-- cIntRep is the Width for a C-language 'int'
205 206
cIntWidth :: Platform -> Width
cIntWidth platform = case pc_CINT_SIZE (platformConstants platform) of
ian@well-typed.com's avatar
ian@well-typed.com committed
207 208 209
                   4 -> W32
                   8 -> W64
                   s -> panic ("cIntWidth: Unknown cINT_SIZE: " ++ show s)
210 211 212 213 214 215 216

widthInBits :: Width -> Int
widthInBits W8   = 8
widthInBits W16  = 16
widthInBits W32  = 32
widthInBits W64  = 64
widthInBits W128 = 128
217
widthInBits W256 = 256
218
widthInBits W512 = 512
219

220 221 222 223 224 225 226

widthInBytes :: Width -> Int
widthInBytes W8   = 1
widthInBytes W16  = 2
widthInBytes W32  = 4
widthInBytes W64  = 8
widthInBytes W128 = 16
227
widthInBytes W256 = 32
228
widthInBytes W512 = 64
229

230 231 232 233 234 235 236

widthFromBytes :: Int -> Width
widthFromBytes 1  = W8
widthFromBytes 2  = W16
widthFromBytes 4  = W32
widthFromBytes 8  = W64
widthFromBytes 16 = W128
237
widthFromBytes 32 = W256
238
widthFromBytes 64 = W512
239

240 241 242 243 244 245 246 247 248
widthFromBytes n  = pprPanic "no width for given number of bytes" (ppr n)

-- log_2 of the width in bytes, useful for generating shifts.
widthInLog :: Width -> Int
widthInLog W8   = 0
widthInLog W16  = 1
widthInLog W32  = 2
widthInLog W64  = 3
widthInLog W128 = 4
249
widthInLog W256 = 5
250
widthInLog W512 = 6
251

252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268

-- widening / narrowing

narrowU :: Width -> Integer -> Integer
narrowU W8  x = fromIntegral (fromIntegral x :: Word8)
narrowU W16 x = fromIntegral (fromIntegral x :: Word16)
narrowU W32 x = fromIntegral (fromIntegral x :: Word32)
narrowU W64 x = fromIntegral (fromIntegral x :: Word64)
narrowU _ _ = panic "narrowTo"

narrowS :: Width -> Integer -> Integer
narrowS W8  x = fromIntegral (fromIntegral x :: Int8)
narrowS W16 x = fromIntegral (fromIntegral x :: Int16)
narrowS W32 x = fromIntegral (fromIntegral x :: Int32)
narrowS W64 x = fromIntegral (fromIntegral x :: Int64)
narrowS _ _ = panic "narrowTo"

269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
-----------------------------------------------------------------------------
--              SIMD
-----------------------------------------------------------------------------

type Length = Int

vec :: Length -> CmmType -> CmmType
vec l (CmmType cat w) = CmmType (VecCat l cat) vecw
  where
    vecw :: Width
    vecw = widthFromBytes (l*widthInBytes w)

vec2, vec4, vec8, vec16 :: CmmType -> CmmType
vec2  = vec 2
vec4  = vec 4
vec8  = vec 8
vec16 = vec 16

vec2f64, vec2b64, vec4f32, vec4b32, vec8b16, vec16b8 :: CmmType
vec2f64 = vec 2 f64
vec2b64 = vec 2 b64
vec4f32 = vec 4 f32
vec4b32 = vec 4 b32
vec8b16 = vec 8 b16
vec16b8 = vec 16 b8

cmmVec :: Int -> CmmType -> CmmType
cmmVec n (CmmType cat w) =
    CmmType (VecCat n cat) (widthFromBytes (n*widthInBytes w))

vecLength :: CmmType -> Length
vecLength (CmmType (VecCat l _) _) = l
vecLength _                        = panic "vecLength: not a vector"

vecElemType :: CmmType -> CmmType
vecElemType (CmmType (VecCat l cat) w) = CmmType cat scalw
  where
    scalw :: Width
    scalw = widthFromBytes (widthInBytes w `div` l)
vecElemType _ = panic "vecElemType: not a vector"

isVecType :: CmmType -> Bool
isVecType (CmmType (VecCat {}) _) = True
isVecType _                       = False

314 315 316 317 318 319
-------------------------------------------------------------------------
-- Hints

-- Hints are extra type information we attach to the arguments and
-- results of a foreign call, where more type information is sometimes
-- needed by the ABI to make the correct kind of call.
320 321
--
-- See Note [Signed vs unsigned] for one case where this is used.
322 323 324 325 326 327 328

data ForeignHint
  = NoHint | AddrHint | SignedHint
  deriving( Eq )
        -- Used to give extra per-argument or per-result
        -- information needed by foreign calling conventions

329 330 331 332 333
-------------------------------------------------------------------------

-- These don't really belong here, but I don't know where is best to
-- put them.

334 335
rEP_CostCentreStack_mem_alloc :: Platform -> CmmType
rEP_CostCentreStack_mem_alloc platform
336
    = cmmBits (widthFromBytes (pc_REP_CostCentreStack_mem_alloc pc))
337
    where pc = platformConstants platform
338

339 340
rEP_CostCentreStack_scc_count :: Platform -> CmmType
rEP_CostCentreStack_scc_count platform
341
    = cmmBits (widthFromBytes (pc_REP_CostCentreStack_scc_count pc))
342
    where pc = platformConstants platform
343

344 345
rEP_StgEntCounter_allocs :: Platform -> CmmType
rEP_StgEntCounter_allocs platform
346
    = cmmBits (widthFromBytes (pc_REP_StgEntCounter_allocs pc))
347
    where pc = platformConstants platform
348

349 350
rEP_StgEntCounter_allocd :: Platform -> CmmType
rEP_StgEntCounter_allocd platform
nfrisby's avatar
nfrisby committed
351
    = cmmBits (widthFromBytes (pc_REP_StgEntCounter_allocd pc))
352
    where pc = platformConstants platform
nfrisby's avatar
nfrisby committed
353

354 355 356 357 358 359 360 361 362 363 364 365 366
-------------------------------------------------------------------------
{-      Note [Signed vs unsigned]
        ~~~~~~~~~~~~~~~~~~~~~~~~~
Should a CmmType include a signed vs. unsigned distinction?

This is very much like a "hint" in C-- terminology: it isn't necessary
in order to generate correct code, but it might be useful in that the
compiler can generate better code if it has access to higher-level
hints about data.  This is important at call boundaries, because the
definition of a function is not visible at all of its call sites, so
the compiler cannot infer the hints.

Here in Cmm, we're taking a slightly different approach.  We include
Simon Marlow's avatar
Simon Marlow committed
367
the int vs. float hint in the CmmType, because (a) the majority of
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
platforms have a strong distinction between float and int registers,
and (b) we don't want to do any heavyweight hint-inference in the
native code backend in order to get good code.  We're treating the
hint more like a type: our Cmm is always completely consistent with
respect to hints.  All coercions between float and int are explicit.

What about the signed vs. unsigned hint?  This information might be
useful if we want to keep sub-word-sized values in word-size
registers, which we must do if we only have word-sized registers.

On such a system, there are two straightforward conventions for
representing sub-word-sized values:

(a) Leave the upper bits undefined.  Comparison operations must
    sign- or zero-extend both operands before comparing them,
    depending on whether the comparison is signed or unsigned.

(b) Always keep the values sign- or zero-extended as appropriate.
    Arithmetic operations must narrow the result to the appropriate
    size.

A clever compiler might not use either (a) or (b) exclusively, instead
it would attempt to minimize the coercions by analysis: the same kind
of analysis that propagates hints around.  In Cmm we don't want to
have to do this, so we plump for having richer types and keeping the
type information consistent.

Simon Marlow's avatar
Simon Marlow committed
395
If signed/unsigned hints are missing from CmmType, then the only
396 397 398 399 400 401 402 403 404 405 406 407 408 409
choice we have is (a), because we don't know whether the result of an
operation should be sign- or zero-extended.

Many architectures have extending load operations, which work well
with (b).  To make use of them with (a), you need to know whether the
value is going to be sign- or zero-extended by an enclosing comparison
(for example), which involves knowing above the context.  This is
doable but more complex.

Further complicating the issue is foreign calls: a foreign calling
convention can specify that signed 8-bit quantities are passed as
sign-extended 32 bit quantities, for example (this is the case on the
PowerPC).  So we *do* need sign information on foreign call arguments.

Simon Marlow's avatar
Simon Marlow committed
410
Pros for adding signed vs. unsigned to CmmType:
411 412 413 414 415 416 417 418 419 420 421 422

  - It would let us use convention (b) above, and get easier
    code generation for extending loads.

  - Less information required on foreign calls.

  - MachOp type would be simpler

Cons:

  - More complexity

Simon Marlow's avatar
Simon Marlow committed
423
  - What is the CmmType for a VanillaReg?  Currently it is
424 425
    always wordRep, but now we have to decide whether it is
    signed or unsigned.  The same VanillaReg can thus have
Simon Marlow's avatar
Simon Marlow committed
426
    different CmmType in different parts of the program.
427 428 429 430 431

  - Extra coercions cluttering up expressions.

Currently for GHC, the foreign call point is moot, because we do our
own promotion of sub-word-sized values to word-sized values.  The Int8
Gabor Greif's avatar
Gabor Greif committed
432
type is represented by an Int# which is kept sign-extended at all times
433 434 435 436 437 438
(this is slightly naughty, because we're making assumptions about the
C calling convention rather early on in the compiler).  However, given
this, the cons outweigh the pros.

-}