ghc/compiler/prelude/TysPrim.lhs

   1 %
   2 % (c) The AQUA Project, Glasgow University, 1994-1998
   3 %
   4 \section[TysPrim]{Wired-in knowledge about primitive types}
   5
   6 \begin{code}
   7 module TysPrim(
   8         alphaTyVars, betaTyVars, alphaTyVar, betaTyVar, gammaTyVar, deltaTyVar,
   9         alphaTy, betaTy, gammaTy, deltaTy,
  10         openAlphaTy, openAlphaTyVar, openAlphaTyVars,
  11
  12         primTyCons,
  13
  14         charPrimTyCon,          charPrimTy,
  15         intPrimTyCon,           intPrimTy,
  16         wordPrimTyCon,          wordPrimTy,
  17         addrPrimTyCon,          addrPrimTy,
  18         floatPrimTyCon,         floatPrimTy,
  19         doublePrimTyCon,        doublePrimTy,
  20
  21         statePrimTyCon,         mkStatePrimTy,
  22         realWorldTyCon,         realWorldTy, realWorldStatePrimTy,
  23
  24         arrayPrimTyCon,                 mkArrayPrimTy,
  25         byteArrayPrimTyCon,             byteArrayPrimTy,
  26         mutableArrayPrimTyCon,          mkMutableArrayPrimTy,
  27         mutableByteArrayPrimTyCon,      mkMutableByteArrayPrimTy,
  28         mutVarPrimTyCon,                mkMutVarPrimTy,
  29
  30         mVarPrimTyCon,                  mkMVarPrimTy,
  31         tVarPrimTyCon,                  mkTVarPrimTy,
  32         stablePtrPrimTyCon,             mkStablePtrPrimTy,
  33         stableNamePrimTyCon,            mkStableNamePrimTy,
  34         bcoPrimTyCon,                   bcoPrimTy,
  35         weakPrimTyCon,                  mkWeakPrimTy,
  36         foreignObjPrimTyCon,            foreignObjPrimTy,
  37         threadIdPrimTyCon,              threadIdPrimTy,
  38
  39         int32PrimTyCon,         int32PrimTy,
  40         word32PrimTyCon,        word32PrimTy,
  41
  42         int64PrimTyCon,         int64PrimTy,
  43         word64PrimTyCon,        word64PrimTy
  44   ) where
  45
  46 #include "HsVersions.h"
  47
  48 import Var              ( TyVar, mkTyVar )
  49 import Name             ( Name, BuiltInSyntax(..), mkInternalName, mkWiredInName )
  50 import OccName          ( mkVarOcc, mkOccFS, tcName )
  51 import TyCon            ( TyCon, ArgVrcs, mkPrimTyCon, mkLiftedPrimTyCon,
  52                           PrimRep(..) )
  53 import Type             ( mkTyConApp, mkTyConTy, mkTyVarTys, mkTyVarTy,
  54                           unliftedTypeKind, liftedTypeKind, openTypeKind,
  55                           Kind, mkArrowKinds,
  56                           TyThing(..)
  57                         )
  58 import SrcLoc           ( noSrcLoc )
  59 import Unique           ( mkAlphaTyVarUnique )
  60 import PrelNames
  61 import FastString       ( FastString, mkFastString )
  62 import Outputable
  63
  64 import Char             ( ord, chr )
  65 \end{code}
  66
  67 %************************************************************************
  68 %*                                                                      *
  69 \subsection{Primitive type constructors}
  70 %*                                                                      *
  71 %************************************************************************
  72
  73 \begin{code}
  74 primTyCons :: [TyCon]
  75 primTyCons
  76   = [ addrPrimTyCon
  77     , arrayPrimTyCon
  78     , byteArrayPrimTyCon
  79     , charPrimTyCon
  80     , doublePrimTyCon
  81     , floatPrimTyCon
  82     , intPrimTyCon
  83     , int32PrimTyCon
  84     , int64PrimTyCon
  85     , foreignObjPrimTyCon
  86     , bcoPrimTyCon
  87     , weakPrimTyCon
  88     , mutableArrayPrimTyCon
  89     , mutableByteArrayPrimTyCon
  90     , mVarPrimTyCon
  91     , tVarPrimTyCon
  92     , mutVarPrimTyCon
  93     , realWorldTyCon
  94     , stablePtrPrimTyCon
  95     , stableNamePrimTyCon
  96     , statePrimTyCon
  97     , threadIdPrimTyCon
  98     , wordPrimTyCon
  99     , word32PrimTyCon
 100     , word64PrimTyCon
 101     ]
 102
 103 mkPrimTc :: FastString -> Unique -> TyCon -> Name
 104 mkPrimTc fs uniq tycon
 105   = mkWiredInName gHC_PRIM (mkOccFS tcName fs)
 106                   uniq
 107                   Nothing               -- No parent object
 108                   (ATyCon tycon)        -- Relevant TyCon
 109                   UserSyntax            -- None are built-in syntax
 110
 111 charPrimTyConName             = mkPrimTc FSLIT("Char#") charPrimTyConKey charPrimTyCon
 112 intPrimTyConName              = mkPrimTc FSLIT("Int#") intPrimTyConKey  intPrimTyCon
 113 int32PrimTyConName            = mkPrimTc FSLIT("Int32#") int32PrimTyConKey int32PrimTyCon
 114 int64PrimTyConName            = mkPrimTc FSLIT("Int64#") int64PrimTyConKey int64PrimTyCon
 115 wordPrimTyConName             = mkPrimTc FSLIT("Word#") wordPrimTyConKey wordPrimTyCon
 116 word32PrimTyConName           = mkPrimTc FSLIT("Word32#") word32PrimTyConKey word32PrimTyCon
 117 word64PrimTyConName           = mkPrimTc FSLIT("Word64#") word64PrimTyConKey word64PrimTyCon
 118 addrPrimTyConName             = mkPrimTc FSLIT("Addr#") addrPrimTyConKey addrPrimTyCon
 119 floatPrimTyConName            = mkPrimTc FSLIT("Float#") floatPrimTyConKey floatPrimTyCon
 120 doublePrimTyConName           = mkPrimTc FSLIT("Double#") doublePrimTyConKey doublePrimTyCon
 121 statePrimTyConName            = mkPrimTc FSLIT("State#") statePrimTyConKey statePrimTyCon
 122 realWorldTyConName            = mkPrimTc FSLIT("RealWorld") realWorldTyConKey realWorldTyCon
 123 arrayPrimTyConName            = mkPrimTc FSLIT("Array#") arrayPrimTyConKey arrayPrimTyCon
 124 byteArrayPrimTyConName        = mkPrimTc FSLIT("ByteArray#") byteArrayPrimTyConKey byteArrayPrimTyCon
 125 mutableArrayPrimTyConName     = mkPrimTc FSLIT("MutableArray#") mutableArrayPrimTyConKey mutableArrayPrimTyCon
 126 mutableByteArrayPrimTyConName = mkPrimTc FSLIT("MutableByteArray#") mutableByteArrayPrimTyConKey mutableByteArrayPrimTyCon
 127 mutVarPrimTyConName           = mkPrimTc FSLIT("MutVar#") mutVarPrimTyConKey mutVarPrimTyCon
 128 mVarPrimTyConName             = mkPrimTc FSLIT("MVar#") mVarPrimTyConKey mVarPrimTyCon
 129 tVarPrimTyConName             = mkPrimTc FSLIT("TVar#") tVarPrimTyConKey tVarPrimTyCon
 130 stablePtrPrimTyConName        = mkPrimTc FSLIT("StablePtr#") stablePtrPrimTyConKey stablePtrPrimTyCon
 131 stableNamePrimTyConName       = mkPrimTc FSLIT("StableName#") stableNamePrimTyConKey stableNamePrimTyCon
 132 foreignObjPrimTyConName       = mkPrimTc FSLIT("ForeignObj#") foreignObjPrimTyConKey foreignObjPrimTyCon
 133 bcoPrimTyConName              = mkPrimTc FSLIT("BCO#") bcoPrimTyConKey bcoPrimTyCon
 134 weakPrimTyConName             = mkPrimTc FSLIT("Weak#") weakPrimTyConKey weakPrimTyCon
 135 threadIdPrimTyConName         = mkPrimTc FSLIT("ThreadId#") threadIdPrimTyConKey threadIdPrimTyCon
 136 \end{code}
 137
 138 %************************************************************************
 139 %*                                                                      *
 140 \subsection{Support code}
 141 %*                                                                      *
 142 %************************************************************************
 143
 144 alphaTyVars is a list of type variables for use in templates:
 145         ["a", "b", ..., "z", "t1", "t2", ... ]
 146
 147 \begin{code}
 148 tyVarList :: Kind -> [TyVar]
 149 tyVarList kind = [ mkTyVar (mkInternalName (mkAlphaTyVarUnique u)
 150                                 (mkVarOcc (mkFastString name))
 151                                 noSrcLoc) kind
 152                  | u <- [2..],
 153                    let name | c <= 'z'  = [c]
 154                             | otherwise = 't':show u
 155                             where c = chr (u-2 + ord 'a')
 156                  ]
 157
 158 alphaTyVars :: [TyVar]
 159 alphaTyVars = tyVarList liftedTypeKind
 160
 161 betaTyVars = tail alphaTyVars
 162
 163 alphaTyVar, betaTyVar, gammaTyVar :: TyVar
 164 (alphaTyVar:betaTyVar:gammaTyVar:deltaTyVar:_) = alphaTyVars
 165
 166 alphaTys = mkTyVarTys alphaTyVars
 167 (alphaTy:betaTy:gammaTy:deltaTy:_) = alphaTys
 168
 169         -- openAlphaTyVar is prepared to be instantiated
 170         -- to a lifted or unlifted type variable.  It's used for the
 171         -- result type for "error", so that we can have (error Int# "Help")
 172 openAlphaTyVars :: [TyVar]
 173 openAlphaTyVars@(openAlphaTyVar:_) = tyVarList openTypeKind
 174
 175 openAlphaTy = mkTyVarTy openAlphaTyVar
 176
 177 vrcPos,vrcZero :: (Bool,Bool)
 178 vrcPos  = (True,False)
 179 vrcZero = (False,False)
 180
 181 vrcsP,vrcsZ,vrcsZP :: ArgVrcs
 182 vrcsP  = [vrcPos]
 183 vrcsZ  = [vrcZero]
 184 vrcsZP = [vrcZero,vrcPos]
 185 \end{code}
 186
 187
 188 %************************************************************************
 189 %*                                                                      *
 190 \subsection[TysPrim-basic]{Basic primitive types (@Char#@, @Int#@, etc.)}
 191 %*                                                                      *
 192 %************************************************************************
 193
 194 \begin{code}
 195 -- only used herein
 196 pcPrimTyCon :: Name -> ArgVrcs -> PrimRep -> TyCon
 197 pcPrimTyCon name arg_vrcs rep
 198   = mkPrimTyCon name kind arity arg_vrcs rep
 199   where
 200     arity       = length arg_vrcs
 201     kind        = mkArrowKinds (replicate arity liftedTypeKind) result_kind
 202     result_kind = unliftedTypeKind -- all primitive types are unlifted
 203
 204 pcPrimTyCon0 :: Name -> PrimRep -> TyCon
 205 pcPrimTyCon0 name rep
 206   = mkPrimTyCon name result_kind 0 [] rep
 207   where
 208     result_kind = unliftedTypeKind -- all primitive types are unlifted
 209
 210 charPrimTy      = mkTyConTy charPrimTyCon
 211 charPrimTyCon   = pcPrimTyCon0 charPrimTyConName WordRep
 212
 213 intPrimTy       = mkTyConTy intPrimTyCon
 214 intPrimTyCon    = pcPrimTyCon0 intPrimTyConName IntRep
 215
 216 int32PrimTy     = mkTyConTy int32PrimTyCon
 217 int32PrimTyCon  = pcPrimTyCon0 int32PrimTyConName IntRep
 218
 219 int64PrimTy     = mkTyConTy int64PrimTyCon
 220 int64PrimTyCon  = pcPrimTyCon0 int64PrimTyConName Int64Rep
 221
 222 wordPrimTy      = mkTyConTy wordPrimTyCon
 223 wordPrimTyCon   = pcPrimTyCon0 wordPrimTyConName WordRep
 224
 225 word32PrimTy    = mkTyConTy word32PrimTyCon
 226 word32PrimTyCon = pcPrimTyCon0 word32PrimTyConName WordRep
 227
 228 word64PrimTy    = mkTyConTy word64PrimTyCon
 229 word64PrimTyCon = pcPrimTyCon0 word64PrimTyConName Word64Rep
 230
 231 addrPrimTy      = mkTyConTy addrPrimTyCon
 232 addrPrimTyCon   = pcPrimTyCon0 addrPrimTyConName AddrRep
 233
 234 floatPrimTy     = mkTyConTy floatPrimTyCon
 235 floatPrimTyCon  = pcPrimTyCon0 floatPrimTyConName FloatRep
 236
 237 doublePrimTy    = mkTyConTy doublePrimTyCon
 238 doublePrimTyCon = pcPrimTyCon0 doublePrimTyConName DoubleRep
 239 \end{code}
 240
 241
 242 %************************************************************************
 243 %*                                                                      *
 244 \subsection[TysPrim-state]{The @State#@ type (and @_RealWorld@ types)}
 245 %*                                                                      *
 246 %************************************************************************
 247
 248 State# is the primitive, unlifted type of states.  It has one type parameter,
 249 thus
 250         State# RealWorld
 251 or
 252         State# s
 253
 254 where s is a type variable. The only purpose of the type parameter is to
 255 keep different state threads separate.  It is represented by nothing at all.
 256
 257 \begin{code}
 258 mkStatePrimTy ty = mkTyConApp statePrimTyCon [ty]
 259 statePrimTyCon   = pcPrimTyCon statePrimTyConName vrcsZ VoidRep
 260 \end{code}
 261
 262 RealWorld is deeply magical.  It is *primitive*, but it is not
 263 *unlifted* (hence ptrArg).  We never manipulate values of type
 264 RealWorld; it's only used in the type system, to parameterise State#.
 265
 266 \begin{code}
 267 realWorldTyCon = mkLiftedPrimTyCon realWorldTyConName liftedTypeKind 0 [] PtrRep
 268 realWorldTy          = mkTyConTy realWorldTyCon
 269 realWorldStatePrimTy = mkStatePrimTy realWorldTy        -- State# RealWorld
 270 \end{code}
 271
 272 Note: the ``state-pairing'' types are not truly primitive, so they are
 273 defined in \tr{TysWiredIn.lhs}, not here.
 274
 275
 276 %************************************************************************
 277 %*                                                                      *
 278 \subsection[TysPrim-arrays]{The primitive array types}
 279 %*                                                                      *
 280 %************************************************************************
 281
 282 \begin{code}
 283 arrayPrimTyCon            = pcPrimTyCon  arrayPrimTyConName            vrcsP  PtrRep
 284 mutableArrayPrimTyCon     = pcPrimTyCon  mutableArrayPrimTyConName     vrcsZP PtrRep
 285 mutableByteArrayPrimTyCon = pcPrimTyCon  mutableByteArrayPrimTyConName vrcsZ  PtrRep
 286 byteArrayPrimTyCon        = pcPrimTyCon0 byteArrayPrimTyConName               PtrRep
 287
 288 mkArrayPrimTy elt           = mkTyConApp arrayPrimTyCon [elt]
 289 byteArrayPrimTy             = mkTyConTy byteArrayPrimTyCon
 290 mkMutableArrayPrimTy s elt  = mkTyConApp mutableArrayPrimTyCon [s, elt]
 291 mkMutableByteArrayPrimTy s  = mkTyConApp mutableByteArrayPrimTyCon [s]
 292 \end{code}
 293
 294 %************************************************************************
 295 %*                                                                      *
 296 \subsection[TysPrim-mut-var]{The mutable variable type}
 297 %*                                                                      *
 298 %************************************************************************
 299
 300 \begin{code}
 301 mutVarPrimTyCon = pcPrimTyCon mutVarPrimTyConName vrcsZP PtrRep
 302
 303 mkMutVarPrimTy s elt        = mkTyConApp mutVarPrimTyCon [s, elt]
 304 \end{code}
 305
 306 %************************************************************************
 307 %*                                                                      *
 308 \subsection[TysPrim-synch-var]{The synchronizing variable type}
 309 %*                                                                      *
 310 %************************************************************************
 311
 312 \begin{code}
 313 mVarPrimTyCon = pcPrimTyCon mVarPrimTyConName vrcsZP PtrRep
 314
 315 mkMVarPrimTy s elt          = mkTyConApp mVarPrimTyCon [s, elt]
 316 \end{code}
 317
 318 %************************************************************************
 319 %*                                                                      *
 320 \subsection[TysPrim-stm-var]{The transactional variable type}
 321 %*                                                                      *
 322 %************************************************************************
 323
 324 \begin{code}
 325 tVarPrimTyCon = pcPrimTyCon tVarPrimTyConName vrcsZP PtrRep
 326
 327 mkTVarPrimTy s elt          = mkTyConApp tVarPrimTyCon [s, elt]
 328 \end{code}
 329
 330 %************************************************************************
 331 %*                                                                      *
 332 \subsection[TysPrim-stable-ptrs]{The stable-pointer type}
 333 %*                                                                      *
 334 %************************************************************************
 335
 336 \begin{code}
 337 stablePtrPrimTyCon = pcPrimTyCon stablePtrPrimTyConName vrcsP AddrRep
 338
 339 mkStablePtrPrimTy ty = mkTyConApp stablePtrPrimTyCon [ty]
 340 \end{code}
 341
 342 %************************************************************************
 343 %*                                                                      *
 344 \subsection[TysPrim-stable-names]{The stable-name type}
 345 %*                                                                      *
 346 %************************************************************************
 347
 348 \begin{code}
 349 stableNamePrimTyCon = pcPrimTyCon stableNamePrimTyConName vrcsP PtrRep
 350
 351 mkStableNamePrimTy ty = mkTyConApp stableNamePrimTyCon [ty]
 352 \end{code}
 353
 354 %************************************************************************
 355 %*                                                                      *
 356 \subsection[TysPrim-foreign-objs]{The ``foreign object'' type}
 357 %*                                                                      *
 358 %************************************************************************
 359
 360 A Foreign Object is just a boxed, unlifted, Addr#.  They're needed
 361 because finalisers (weak pointers) can't watch Addr#s, they can only
 362 watch heap-resident objects.
 363
 364 We can't use a lifted Addr# (such as Addr) because race conditions
 365 could bite us.  For example, if the program deconstructed the Addr
 366 before passing its contents to a ccall, and a weak pointer was
 367 watching the Addr, the weak pointer might deduce that the Addr was
 368 dead before it really was.
 369
 370 \begin{code}
 371 foreignObjPrimTy    = mkTyConTy foreignObjPrimTyCon
 372 foreignObjPrimTyCon = pcPrimTyCon0 foreignObjPrimTyConName PtrRep
 373 \end{code}
 374
 375 %************************************************************************
 376 %*                                                                      *
 377 \subsection[TysPrim-BCOs]{The ``bytecode object'' type}
 378 %*                                                                      *
 379 %************************************************************************
 380
 381 \begin{code}
 382 bcoPrimTy    = mkTyConTy bcoPrimTyCon
 383 bcoPrimTyCon = pcPrimTyCon0 bcoPrimTyConName PtrRep
 384 \end{code}
 385
 386 %************************************************************************
 387 %*                                                                      *
 388 \subsection[TysPrim-Weak]{The ``weak pointer'' type}
 389 %*                                                                      *
 390 %************************************************************************
 391
 392 \begin{code}
 393 weakPrimTyCon = pcPrimTyCon weakPrimTyConName vrcsP PtrRep
 394
 395 mkWeakPrimTy v = mkTyConApp weakPrimTyCon [v]
 396 \end{code}
 397
 398 %************************************************************************
 399 %*                                                                      *
 400 \subsection[TysPrim-thread-ids]{The ``thread id'' type}
 401 %*                                                                      *
 402 %************************************************************************
 403
 404 A thread id is represented by a pointer to the TSO itself, to ensure
 405 that they are always unique and we can always find the TSO for a given
 406 thread id.  However, this has the unfortunate consequence that a
 407 ThreadId# for a given thread is treated as a root by the garbage
 408 collector and can keep TSOs around for too long.
 409
 410 Hence the programmer API for thread manipulation uses a weak pointer
 411 to the thread id internally.
 412
 413 \begin{code}
 414 threadIdPrimTy    = mkTyConTy threadIdPrimTyCon
 415 threadIdPrimTyCon = pcPrimTyCon0 threadIdPrimTyConName PtrRep
 416 \end{code}