compiler/codeGen/SMRep.lhs

   1 %
   2 % (c) The University of Glasgow 2006
   3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   4 %
   5
   6 Storage manager representation of closures
   7
   8 This is here, rather than in ClosureInfo, just to keep nhc happy.
   9 Other modules should access this info through ClosureInfo.
  10
  11 \begin{code}
  12 {-# OPTIONS -w #-}
  13 -- The above warning supression flag is a temporary kludge.
  14 -- While working on this module you are encouraged to remove it and fix
  15 -- any warnings in the module. See
  16 --     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
  17 -- for details
  18
  19 module SMRep (
  20         -- Words and bytes
  21         StgWord, StgHalfWord,
  22         hALF_WORD_SIZE, hALF_WORD_SIZE_IN_BITS,
  23         WordOff, ByteOff,
  24
  25         -- Argument/return representations
  26         CgRep(..), nonVoidArg,
  27         argMachRep, primRepToCgRep, primRepHint,
  28         isFollowableArg, isVoidArg,
  29         isFloatingArg, is64BitArg,
  30         separateByPtrFollowness,
  31         cgRepSizeW, cgRepSizeB,
  32         retAddrSizeW,
  33
  34         typeCgRep, idCgRep, tyConCgRep, typeHint,
  35
  36         -- Closure repesentation
  37         SMRep(..), ClosureType(..),
  38         isStaticRep,
  39         fixedHdrSize, arrWordsHdrSize, arrPtrsHdrSize,
  40         profHdrSize, thunkHdrSize,
  41         smRepClosureType, smRepClosureTypeInt,
  42
  43         rET_SMALL, rET_BIG
  44     ) where
  45
  46 #include "HsVersions.h"
  47 #include "../includes/MachDeps.h"
  48
  49 import Id
  50 import Type
  51 import TyCon
  52 import MachOp
  53 import StaticFlags
  54 import Constants
  55 import Outputable
  56 import FastString
  57
  58 import Data.Word
  59 \end{code}
  60
  61
  62 %************************************************************************
  63 %*                                                                      *
  64                 Words and bytes
  65 %*                                                                      *
  66 %************************************************************************
  67
  68 \begin{code}
  69 type WordOff = Int      -- Word offset, or word count
  70 type ByteOff = Int      -- Byte offset, or byte count
  71 \end{code}
  72
  73 StgWord is a type representing an StgWord on the target platform.
  74
  75 \begin{code}
  76 #if SIZEOF_HSWORD == 4
  77 type StgWord     = Word32
  78 type StgHalfWord = Word16
  79 hALF_WORD_SIZE = 2 :: ByteOff
  80 hALF_WORD_SIZE_IN_BITS = 16 :: Int
  81 #elif SIZEOF_HSWORD == 8
  82 type StgWord     = Word64
  83 type StgHalfWord = Word32
  84 hALF_WORD_SIZE = 4 :: ByteOff
  85 hALF_WORD_SIZE_IN_BITS = 32 :: Int
  86 #else
  87 #error unknown SIZEOF_HSWORD
  88 #endif
  89 \end{code}
  90
  91
  92 %************************************************************************
  93 %*                                                                      *
  94                         CgRep
  95 %*                                                                      *
  96 %************************************************************************
  97
  98 An CgRep is an abstraction of a Type which tells the code generator
  99 all it needs to know about the calling convention for arguments (and
 100 results) of that type.  In particular, the ArgReps of a function's
 101 arguments are used to decide which of the RTS's generic apply
 102 functions to call when applying an unknown function.
 103
 104 It contains more information than the back-end data type MachRep,
 105 so one can easily convert from CgRep -> MachRep.  (Except that
 106 there's no MachRep for a VoidRep.)
 107
 108 It distinguishes
 109         pointers from non-pointers (we sort the pointers together
 110         when building closures)
 111
 112         void from other types: a void argument is different from no argument
 113
 114 All 64-bit types map to the same CgRep, because they're passed in the
 115 same register, but a PtrArg is still different from an NonPtrArg
 116 because the function's entry convention has to take into account the
 117 pointer-hood of arguments for the purposes of describing the stack on
 118 entry to the garbage collector.
 119
 120 \begin{code}
 121 data CgRep
 122   = VoidArg     -- Void
 123   | PtrArg      -- Word-sized heap pointer, followed
 124                 -- by the garbage collector
 125   | NonPtrArg   -- Word-sized non-pointer
 126                 -- (including addresses not followed by GC)
 127   | LongArg     -- 64-bit non-pointer
 128   | FloatArg    -- 32-bit float
 129   | DoubleArg   -- 64-bit float
 130   deriving Eq
 131
 132 instance Outputable CgRep where
 133     ppr VoidArg   = ptext SLIT("V_")
 134     ppr PtrArg    = ptext SLIT("P_")
 135     ppr NonPtrArg = ptext SLIT("I_")
 136     ppr LongArg   = ptext SLIT("L_")
 137     ppr FloatArg  = ptext SLIT("F_")
 138     ppr DoubleArg = ptext SLIT("D_")
 139
 140 argMachRep :: CgRep -> MachRep
 141 argMachRep PtrArg    = wordRep
 142 argMachRep NonPtrArg = wordRep
 143 argMachRep LongArg   = I64
 144 argMachRep FloatArg  = F32
 145 argMachRep DoubleArg = F64
 146 argMachRep VoidArg   = panic "argMachRep:VoidRep"
 147
 148 primRepToCgRep :: PrimRep -> CgRep
 149 primRepToCgRep VoidRep    = VoidArg
 150 primRepToCgRep PtrRep     = PtrArg
 151 primRepToCgRep IntRep     = NonPtrArg
 152 primRepToCgRep WordRep    = NonPtrArg
 153 primRepToCgRep Int64Rep   = LongArg
 154 primRepToCgRep Word64Rep  = LongArg
 155 primRepToCgRep AddrRep    = NonPtrArg
 156 primRepToCgRep FloatRep   = FloatArg
 157 primRepToCgRep DoubleRep  = DoubleArg
 158
 159 primRepHint :: PrimRep -> MachHint
 160 primRepHint VoidRep     = panic "primRepHint:VoidRep"
 161 primRepHint PtrRep      = PtrHint
 162 primRepHint IntRep      = SignedHint
 163 primRepHint WordRep     = NoHint
 164 primRepHint Int64Rep    = SignedHint
 165 primRepHint Word64Rep   = NoHint
 166 primRepHint AddrRep     = PtrHint -- NB! PtrHint, but NonPtrArg
 167 primRepHint FloatRep    = FloatHint
 168 primRepHint DoubleRep   = FloatHint
 169
 170 idCgRep :: Id -> CgRep
 171 idCgRep x = typeCgRep . idType $ x
 172
 173 tyConCgRep :: TyCon -> CgRep
 174 tyConCgRep = primRepToCgRep . tyConPrimRep
 175
 176 typeCgRep :: Type -> CgRep
 177 typeCgRep = primRepToCgRep . typePrimRep
 178
 179 typeHint :: Type -> MachHint
 180 typeHint = primRepHint . typePrimRep
 181 \end{code}
 182
 183 Whether or not the thing is a pointer that the garbage-collector
 184 should follow. Or, to put it another (less confusing) way, whether
 185 the object in question is a heap object.
 186
 187 Depending on the outcome, this predicate determines what stack
 188 the pointer/object possibly will have to be saved onto, and the
 189 computation of GC liveness info.
 190
 191 \begin{code}
 192 isFollowableArg :: CgRep -> Bool  -- True <=> points to a heap object
 193 isFollowableArg PtrArg  = True
 194 isFollowableArg other = False
 195
 196 isVoidArg :: CgRep -> Bool
 197 isVoidArg VoidArg = True
 198 isVoidArg other   = False
 199
 200 nonVoidArg :: CgRep -> Bool
 201 nonVoidArg VoidArg = False
 202 nonVoidArg other   = True
 203
 204 -- isFloatingArg is used to distinguish @Double@ and @Float@ which
 205 -- cause inadvertent numeric conversions if you aren't jolly careful.
 206 -- See codeGen/CgCon:cgTopRhsCon.
 207
 208 isFloatingArg :: CgRep -> Bool
 209 isFloatingArg DoubleArg = True
 210 isFloatingArg FloatArg  = True
 211 isFloatingArg _         = False
 212
 213 is64BitArg :: CgRep -> Bool
 214 is64BitArg LongArg = True
 215 is64BitArg _       = False
 216 \end{code}
 217
 218 \begin{code}
 219 separateByPtrFollowness :: [(CgRep,a)] -> ([(CgRep,a)], [(CgRep,a)])
 220 -- Returns (ptrs, non-ptrs)
 221 separateByPtrFollowness things
 222   = sep_things things [] []
 223     -- accumulating params for follow-able and don't-follow things...
 224   where
 225     sep_things []              bs us = (reverse bs, reverse us)
 226     sep_things ((PtrArg,a):ts) bs us = sep_things ts ((PtrArg,a):bs) us
 227     sep_things (t         :ts) bs us = sep_things ts bs              (t:us)
 228 \end{code}
 229
 230 \begin{code}
 231 cgRepSizeB :: CgRep -> ByteOff
 232 cgRepSizeB DoubleArg = dOUBLE_SIZE
 233 cgRepSizeB LongArg   = wORD64_SIZE
 234 cgRepSizeB VoidArg   = 0
 235 cgRepSizeB _         = wORD_SIZE
 236
 237 cgRepSizeW :: CgRep -> ByteOff
 238 cgRepSizeW DoubleArg = dOUBLE_SIZE `quot` wORD_SIZE
 239 cgRepSizeW LongArg   = wORD64_SIZE `quot` wORD_SIZE
 240 cgRepSizeW VoidArg   = 0
 241 cgRepSizeW _         = 1
 242
 243 retAddrSizeW :: WordOff
 244 retAddrSizeW = 1        -- One word
 245 \end{code}
 246
 247 %************************************************************************
 248 %*                                                                      *
 249 \subsubsection[SMRep-datatype]{@SMRep@---storage manager representation}
 250 %*                                                                      *
 251 %************************************************************************
 252
 253 \begin{code}
 254 data SMRep
 255      -- static closure have an extra static link field at the end.
 256   = GenericRep          -- GC routines consult sizes in info tbl
 257         Bool            -- True <=> This is a static closure.  Affects how
 258                         --          we garbage-collect it
 259         !Int            --  # ptr words
 260         !Int            --  # non-ptr words
 261         ClosureType     -- closure type
 262
 263   | BlackHoleRep
 264
 265 data ClosureType        -- Corresponds 1-1 with the varieties of closures
 266                         -- implemented by the RTS.  Compare with ghc/includes/ClosureTypes.h
 267     = Constr
 268     | ConstrNoCaf
 269     | Fun
 270     | Thunk
 271     | ThunkSelector
 272 \end{code}
 273
 274 Size of a closure header.
 275
 276 \begin{code}
 277 fixedHdrSize :: WordOff
 278 fixedHdrSize = sTD_HDR_SIZE + profHdrSize + granHdrSize
 279
 280 profHdrSize  :: WordOff
 281 profHdrSize  | opt_SccProfilingOn   = pROF_HDR_SIZE
 282              | otherwise            = 0
 283
 284 granHdrSize  :: WordOff
 285 granHdrSize  | opt_GranMacros       = gRAN_HDR_SIZE
 286              | otherwise            = 0
 287
 288 arrWordsHdrSize   :: ByteOff
 289 arrWordsHdrSize   = fixedHdrSize*wORD_SIZE + sIZEOF_StgArrWords_NoHdr
 290
 291 arrPtrsHdrSize    :: ByteOff
 292 arrPtrsHdrSize    = fixedHdrSize*wORD_SIZE + sIZEOF_StgMutArrPtrs_NoHdr
 293
 294 -- Thunks have an extra header word on SMP, so the update doesn't
 295 -- splat the payload.
 296 thunkHdrSize :: WordOff
 297 thunkHdrSize = fixedHdrSize + smp_hdr
 298         where smp_hdr = sIZEOF_StgSMPThunkHeader `quot` wORD_SIZE
 299 \end{code}
 300
 301 \begin{code}
 302 isStaticRep :: SMRep -> Bool
 303 isStaticRep (GenericRep is_static _ _ _) = is_static
 304 isStaticRep BlackHoleRep                 = False
 305 \end{code}
 306
 307 \begin{code}
 308 #include "../includes/ClosureTypes.h"
 309 -- Defines CONSTR, CONSTR_1_0 etc
 310
 311 -- krc: only called by tickyDynAlloc in CgTicky; return
 312 -- Nothing for a black hole so we can at least make something work.
 313 smRepClosureType :: SMRep -> Maybe ClosureType
 314 smRepClosureType (GenericRep _ _ _ ty) = Just ty
 315 smRepClosureType BlackHoleRep          = Nothing
 316
 317 smRepClosureTypeInt :: SMRep -> StgHalfWord
 318 smRepClosureTypeInt (GenericRep False 1 0 Constr) = CONSTR_1_0
 319 smRepClosureTypeInt (GenericRep False 0 1 Constr) = CONSTR_0_1
 320 smRepClosureTypeInt (GenericRep False 2 0 Constr) = CONSTR_2_0
 321 smRepClosureTypeInt (GenericRep False 1 1 Constr) = CONSTR_1_1
 322 smRepClosureTypeInt (GenericRep False 0 2 Constr) = CONSTR_0_2
 323 smRepClosureTypeInt (GenericRep False _ _ Constr) = CONSTR
 324
 325 smRepClosureTypeInt (GenericRep False 1 0 Fun) = FUN_1_0
 326 smRepClosureTypeInt (GenericRep False 0 1 Fun) = FUN_0_1
 327 smRepClosureTypeInt (GenericRep False 2 0 Fun) = FUN_2_0
 328 smRepClosureTypeInt (GenericRep False 1 1 Fun) = FUN_1_1
 329 smRepClosureTypeInt (GenericRep False 0 2 Fun) = FUN_0_2
 330 smRepClosureTypeInt (GenericRep False _ _ Fun) = FUN
 331
 332 smRepClosureTypeInt (GenericRep False 1 0 Thunk) = THUNK_1_0
 333 smRepClosureTypeInt (GenericRep False 0 1 Thunk) = THUNK_0_1
 334 smRepClosureTypeInt (GenericRep False 2 0 Thunk) = THUNK_2_0
 335 smRepClosureTypeInt (GenericRep False 1 1 Thunk) = THUNK_1_1
 336 smRepClosureTypeInt (GenericRep False 0 2 Thunk) = THUNK_0_2
 337 smRepClosureTypeInt (GenericRep False _ _ Thunk) = THUNK
 338
 339 smRepClosureTypeInt (GenericRep False _ _ ThunkSelector) =  THUNK_SELECTOR
 340
 341 smRepClosureTypeInt (GenericRep True _ _ Constr)      = CONSTR_STATIC
 342 smRepClosureTypeInt (GenericRep True _ _ ConstrNoCaf) = CONSTR_NOCAF_STATIC
 343 smRepClosureTypeInt (GenericRep True _ _ Fun)         = FUN_STATIC
 344 smRepClosureTypeInt (GenericRep True _ _ Thunk)       = THUNK_STATIC
 345
 346 smRepClosureTypeInt BlackHoleRep = BLACKHOLE
 347
 348 smRepClosureTypeInt rep = panic "smRepClosuretypeint"
 349
 350
 351 -- We export these ones
 352 rET_SMALL     = (RET_SMALL     :: StgHalfWord)
 353 rET_BIG       = (RET_BIG       :: StgHalfWord)
 354 \end{code}
 355