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