ghc/compiler/basicTypes/Id.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[Id]{@Ids@: Value and constructor identifiers}
   5
   6 \begin{code}
   7 module Id (
   8         Id, DictId,
   9
  10         -- Simple construction
  11         mkGlobalId, mkLocalId, mkSpecPragmaId, mkLocalIdWithInfo,
  12         mkSysLocal, mkSysLocalUnencoded, mkUserLocal, mkVanillaGlobal,
  13         mkTemplateLocals, mkTemplateLocalsNum, mkWildId, mkTemplateLocal,
  14         mkWorkerId, mkExportedLocalId,
  15
  16         -- Taking an Id apart
  17         idName, idType, idUnique, idInfo,
  18         idPrimRep, isId, globalIdDetails,
  19         recordSelectorFieldLabel,
  20
  21         -- Modifying an Id
  22         setIdName, setIdUnique, Id.setIdType, setIdLocalExported,
  23         setIdInfo, lazySetIdInfo, modifyIdInfo, maybeModifyIdInfo,
  24         zapLamIdInfo, zapDemandIdInfo,
  25
  26         -- Predicates
  27         isImplicitId, isDeadBinder,
  28         isSpecPragmaId, isExportedId, isLocalId, isGlobalId,
  29         isRecordSelector,
  30         isPrimOpId, isPrimOpId_maybe,
  31         isFCallId, isFCallId_maybe,
  32         isDataConWorkId, isDataConWorkId_maybe,
  33         isBottomingId, idIsFrom,
  34         hasNoBinding,
  35
  36         -- Inline pragma stuff
  37         idInlinePragma, setInlinePragma, modifyInlinePragma,
  38
  39
  40         -- One shot lambda stuff
  41         isOneShotBndr, isOneShotLambda, setOneShotLambda, clearOneShotLambda,
  42
  43         -- IdInfo stuff
  44         setIdUnfolding,
  45         setIdArity,
  46         setIdNewDemandInfo,
  47         setIdNewStrictness, zapIdNewStrictness,
  48         setIdWorkerInfo,
  49         setIdSpecialisation,
  50         setIdCafInfo,
  51         setIdOccInfo,
  52
  53 #ifdef OLD_STRICTNESS
  54         idDemandInfo,
  55         idStrictness,
  56         idCprInfo,
  57         setIdStrictness,
  58         setIdDemandInfo,
  59         setIdCprInfo,
  60 #endif
  61
  62         idArity,
  63         idNewDemandInfo, idNewDemandInfo_maybe,
  64         idNewStrictness, idNewStrictness_maybe,
  65         idWorkerInfo,
  66         idUnfolding,
  67         idSpecialisation, idCoreRules,
  68         idCafInfo,
  69         idLBVarInfo,
  70         idOccInfo,
  71
  72 #ifdef OLD_STRICTNESS
  73         newStrictnessFromOld    -- Temporary
  74 #endif
  75
  76     ) where
  77
  78 #include "HsVersions.h"
  79
  80
  81 import CoreSyn          ( Unfolding, CoreRules, IdCoreRule, rulesRules )
  82 import BasicTypes       ( Arity )
  83 import Var              ( Id, DictId,
  84                           isId, isExportedId, isSpecPragmaId, isLocalId,
  85                           idName, idType, idUnique, idInfo, isGlobalId,
  86                           setIdName, setIdType, setIdUnique, setIdLocalExported,
  87                           setIdInfo, lazySetIdInfo, modifyIdInfo,
  88                           maybeModifyIdInfo,
  89                           globalIdDetails
  90                         )
  91 import qualified Var    ( mkLocalId, mkGlobalId, mkSpecPragmaId, mkExportedLocalId )
  92 import Type             ( Type, typePrimRep, addFreeTyVars, seqType, splitTyConApp_maybe )
  93 import TysPrim          ( statePrimTyCon )
  94 import IdInfo
  95
  96 #ifdef OLD_STRICTNESS
  97 import qualified Demand ( Demand )
  98 #endif
  99 import DataCon          ( isUnboxedTupleCon )
 100 import NewDemand        ( Demand, StrictSig, topDmd, topSig, isBottomingSig )
 101 import Name             ( Name, OccName, nameIsLocalOrFrom,
 102                           mkSystemName, mkSystemNameEncoded, mkInternalName,
 103                           getOccName, getSrcLoc
 104                         )
 105 import Module           ( Module )
 106 import OccName          ( EncodedFS, mkWorkerOcc )
 107 import PrimRep          ( PrimRep )
 108 import FieldLabel       ( FieldLabel )
 109 import Maybes           ( orElse )
 110 import SrcLoc           ( SrcLoc )
 111 import Outputable
 112 import Unique           ( Unique, mkBuiltinUnique )
 113 import CmdLineOpts      ( opt_NoStateHack )
 114
 115 -- infixl so you can say (id `set` a `set` b)
 116 infixl  1 `setIdUnfolding`,
 117           `setIdArity`,
 118           `setIdNewDemandInfo`,
 119           `setIdNewStrictness`,
 120           `setIdWorkerInfo`,
 121           `setIdSpecialisation`,
 122           `setInlinePragma`,
 123           `idCafInfo`
 124 #ifdef OLD_STRICTNESS
 125           ,`idCprInfo`
 126           ,`setIdStrictness`
 127           ,`setIdDemandInfo`
 128 #endif
 129 \end{code}
 130
 131
 132
 133 %************************************************************************
 134 %*                                                                      *
 135 \subsection{Simple Id construction}
 136 %*                                                                      *
 137 %************************************************************************
 138
 139 Absolutely all Ids are made by mkId.  It is just like Var.mkId,
 140 but in addition it pins free-tyvar-info onto the Id's type,
 141 where it can easily be found.
 142
 143 \begin{code}
 144 mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id
 145 mkLocalIdWithInfo name ty info = Var.mkLocalId name (addFreeTyVars ty) info
 146
 147 mkSpecPragmaId :: Name -> Type -> Id
 148 mkSpecPragmaId name ty = Var.mkSpecPragmaId name (addFreeTyVars ty) vanillaIdInfo
 149
 150 mkExportedLocalId :: Name -> Type -> Id
 151 mkExportedLocalId name ty = Var.mkExportedLocalId name (addFreeTyVars ty) vanillaIdInfo
 152
 153 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
 154 mkGlobalId details name ty info = Var.mkGlobalId details name (addFreeTyVars ty) info
 155 \end{code}
 156
 157 \begin{code}
 158 mkLocalId :: Name -> Type -> Id
 159 mkLocalId name ty = mkLocalIdWithInfo name ty vanillaIdInfo
 160
 161 -- SysLocal: for an Id being created by the compiler out of thin air...
 162 -- UserLocal: an Id with a name the user might recognize...
 163 mkUserLocal :: OccName -> Unique -> Type -> SrcLoc -> Id
 164 mkSysLocal  :: EncodedFS  -> Unique -> Type -> Id
 165 mkVanillaGlobal :: Name -> Type -> IdInfo -> Id
 166
 167 -- for SysLocal, we assume the base name is already encoded, to avoid
 168 -- re-encoding the same string over and over again.
 169 mkSysLocal          fs uniq ty = mkLocalId (mkSystemNameEncoded uniq fs) ty
 170
 171 -- version to use when the faststring needs to be encoded
 172 mkSysLocalUnencoded fs uniq ty = mkLocalId (mkSystemName uniq fs)        ty
 173
 174 mkUserLocal occ uniq ty loc = mkLocalId (mkInternalName    uniq occ loc) ty
 175 mkVanillaGlobal             = mkGlobalId VanillaGlobal
 176 \end{code}
 177
 178 Make some local @Ids@ for a template @CoreExpr@.  These have bogus
 179 @Uniques@, but that's OK because the templates are supposed to be
 180 instantiated before use.
 181
 182 \begin{code}
 183 -- "Wild Id" typically used when you need a binder that you don't expect to use
 184 mkWildId :: Type -> Id
 185 mkWildId ty = mkSysLocal FSLIT("wild") (mkBuiltinUnique 1) ty
 186
 187 mkWorkerId :: Unique -> Id -> Type -> Id
 188 -- A worker gets a local name.  CoreTidy will externalise it if necessary.
 189 mkWorkerId uniq unwrkr ty
 190   = mkLocalId wkr_name ty
 191   where
 192     wkr_name = mkInternalName uniq (mkWorkerOcc (getOccName unwrkr)) (getSrcLoc unwrkr)
 193
 194 -- "Template locals" typically used in unfoldings
 195 mkTemplateLocals :: [Type] -> [Id]
 196 mkTemplateLocals tys = zipWith mkTemplateLocal [1..] tys
 197
 198 mkTemplateLocalsNum :: Int -> [Type] -> [Id]
 199 -- The Int gives the starting point for unique allocation
 200 mkTemplateLocalsNum n tys = zipWith mkTemplateLocal [n..] tys
 201
 202 mkTemplateLocal :: Int -> Type -> Id
 203 mkTemplateLocal i ty = mkSysLocal FSLIT("tpl") (mkBuiltinUnique i) ty
 204 \end{code}
 205
 206
 207 %************************************************************************
 208 %*                                                                      *
 209 \subsection[Id-general-funs]{General @Id@-related functions}
 210 %*                                                                      *
 211 %************************************************************************
 212
 213 \begin{code}
 214 setIdType :: Id -> Type -> Id
 215         -- Add free tyvar info to the type
 216 setIdType id ty = seqType ty `seq` Var.setIdType id (addFreeTyVars ty)
 217
 218 idPrimRep :: Id -> PrimRep
 219 idPrimRep id = typePrimRep (idType id)
 220 \end{code}
 221
 222
 223 %************************************************************************
 224 %*                                                                      *
 225 \subsection{Special Ids}
 226 %*                                                                      *
 227 %************************************************************************
 228
 229 The @SpecPragmaId@ exists only to make Ids that are
 230 on the *LHS* of bindings created by SPECIALISE pragmas;
 231 eg:             s = f Int d
 232 The SpecPragmaId is never itself mentioned; it
 233 exists solely so that the specialiser will find
 234 the call to f, and make specialised version of it.
 235 The SpecPragmaId binding is discarded by the specialiser
 236 when it gathers up overloaded calls.
 237 Meanwhile, it is not discarded as dead code.
 238
 239
 240 \begin{code}
 241 recordSelectorFieldLabel :: Id -> FieldLabel
 242 recordSelectorFieldLabel id = case globalIdDetails id of
 243                                  RecordSelId lbl -> lbl
 244                                  other -> panic "recordSelectorFieldLabel"
 245
 246 isRecordSelector id = case globalIdDetails id of
 247                         RecordSelId lbl -> True
 248                         other           -> False
 249
 250 isPrimOpId id = case globalIdDetails id of
 251                     PrimOpId op -> True
 252                     other       -> False
 253
 254 isPrimOpId_maybe id = case globalIdDetails id of
 255                             PrimOpId op -> Just op
 256                             other       -> Nothing
 257
 258 isFCallId id = case globalIdDetails id of
 259                     FCallId call -> True
 260                     other        -> False
 261
 262 isFCallId_maybe id = case globalIdDetails id of
 263                             FCallId call -> Just call
 264                             other        -> Nothing
 265
 266 isDataConWorkId id = case globalIdDetails id of
 267                         DataConWorkId _ -> True
 268                         other           -> False
 269
 270 isDataConWorkId_maybe id = case globalIdDetails id of
 271                           DataConWorkId con -> Just con
 272                           other             -> Nothing
 273
 274 -- hasNoBinding returns True of an Id which may not have a
 275 -- binding, even though it is defined in this module.
 276 -- Data constructor workers used to be things of this kind, but
 277 -- they aren't any more.  Instead, we inject a binding for
 278 -- them at the CorePrep stage.
 279 -- EXCEPT: unboxed tuples, which definitely have no binding
 280 hasNoBinding id = case globalIdDetails id of
 281                         PrimOpId _       -> True
 282                         FCallId _        -> True
 283                         DataConWorkId dc -> isUnboxedTupleCon dc
 284                         other            -> False
 285
 286 isImplicitId :: Id -> Bool
 287         -- isImplicitId tells whether an Id's info is implied by other
 288         -- declarations, so we don't need to put its signature in an interface
 289         -- file, even if it's mentioned in some other interface unfolding.
 290 isImplicitId id
 291   = case globalIdDetails id of
 292         RecordSelId _   -> True
 293         FCallId _       -> True
 294         PrimOpId _      -> True
 295         ClassOpId _     -> True
 296         DataConWorkId _ -> True
 297         DataConWrapId _ -> True
 298                 -- These are are implied by their type or class decl;
 299                 -- remember that all type and class decls appear in the interface file.
 300                 -- The dfun id is not an implicit Id; it must *not* be omitted, because
 301                 -- it carries version info for the instance decl
 302         other           -> False
 303
 304 idIsFrom :: Module -> Id -> Bool
 305 idIsFrom mod id = nameIsLocalOrFrom mod (idName id)
 306 \end{code}
 307
 308 \begin{code}
 309 isDeadBinder :: Id -> Bool
 310 isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
 311                   | otherwise = False   -- TyVars count as not dead
 312 \end{code}
 313
 314
 315 %************************************************************************
 316 %*                                                                      *
 317 \subsection{IdInfo stuff}
 318 %*                                                                      *
 319 %************************************************************************
 320
 321 \begin{code}
 322         ---------------------------------
 323         -- ARITY
 324 idArity :: Id -> Arity
 325 idArity id = arityInfo (idInfo id)
 326
 327 setIdArity :: Id -> Arity -> Id
 328 setIdArity id arity = modifyIdInfo (`setArityInfo` arity) id
 329
 330 #ifdef OLD_STRICTNESS
 331         ---------------------------------
 332         -- (OLD) STRICTNESS
 333 idStrictness :: Id -> StrictnessInfo
 334 idStrictness id = strictnessInfo (idInfo id)
 335
 336 setIdStrictness :: Id -> StrictnessInfo -> Id
 337 setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
 338 #endif
 339
 340 -- isBottomingId returns true if an application to n args would diverge
 341 isBottomingId :: Id -> Bool
 342 isBottomingId id = isBottomingSig (idNewStrictness id)
 343
 344 idNewStrictness_maybe :: Id -> Maybe StrictSig
 345 idNewStrictness :: Id -> StrictSig
 346
 347 idNewStrictness_maybe id = newStrictnessInfo (idInfo id)
 348 idNewStrictness       id = idNewStrictness_maybe id `orElse` topSig
 349
 350 setIdNewStrictness :: Id -> StrictSig -> Id
 351 setIdNewStrictness id sig = modifyIdInfo (`setNewStrictnessInfo` Just sig) id
 352
 353 zapIdNewStrictness :: Id -> Id
 354 zapIdNewStrictness id = modifyIdInfo (`setNewStrictnessInfo` Nothing) id
 355
 356         ---------------------------------
 357         -- WORKER ID
 358 idWorkerInfo :: Id -> WorkerInfo
 359 idWorkerInfo id = workerInfo (idInfo id)
 360
 361 setIdWorkerInfo :: Id -> WorkerInfo -> Id
 362 setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
 363
 364         ---------------------------------
 365         -- UNFOLDING
 366 idUnfolding :: Id -> Unfolding
 367 idUnfolding id = unfoldingInfo (idInfo id)
 368
 369 setIdUnfolding :: Id -> Unfolding -> Id
 370 setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
 371
 372 #ifdef OLD_STRICTNESS
 373         ---------------------------------
 374         -- (OLD) DEMAND
 375 idDemandInfo :: Id -> Demand.Demand
 376 idDemandInfo id = demandInfo (idInfo id)
 377
 378 setIdDemandInfo :: Id -> Demand.Demand -> Id
 379 setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
 380 #endif
 381
 382 idNewDemandInfo_maybe :: Id -> Maybe NewDemand.Demand
 383 idNewDemandInfo       :: Id -> NewDemand.Demand
 384
 385 idNewDemandInfo_maybe id = newDemandInfo (idInfo id)
 386 idNewDemandInfo       id = newDemandInfo (idInfo id) `orElse` NewDemand.topDmd
 387
 388 setIdNewDemandInfo :: Id -> NewDemand.Demand -> Id
 389 setIdNewDemandInfo id dmd = modifyIdInfo (`setNewDemandInfo` Just dmd) id
 390
 391         ---------------------------------
 392         -- SPECIALISATION
 393 idSpecialisation :: Id -> CoreRules
 394 idSpecialisation id = specInfo (idInfo id)
 395
 396 idCoreRules :: Id -> [IdCoreRule]
 397 idCoreRules id = [(id,rule) | rule <- rulesRules (idSpecialisation id)]
 398
 399 setIdSpecialisation :: Id -> CoreRules -> Id
 400 setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
 401
 402         ---------------------------------
 403         -- CAF INFO
 404 idCafInfo :: Id -> CafInfo
 405 #ifdef OLD_STRICTNESS
 406 idCafInfo id = case cgInfo (idInfo id) of
 407                   NoCgInfo -> pprPanic "idCafInfo" (ppr id)
 408                   info     -> cgCafInfo info
 409 #else
 410 idCafInfo id = cafInfo (idInfo id)
 411 #endif
 412
 413 setIdCafInfo :: Id -> CafInfo -> Id
 414 setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
 415
 416         ---------------------------------
 417         -- CPR INFO
 418 #ifdef OLD_STRICTNESS
 419 idCprInfo :: Id -> CprInfo
 420 idCprInfo id = cprInfo (idInfo id)
 421
 422 setIdCprInfo :: Id -> CprInfo -> Id
 423 setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
 424 #endif
 425
 426         ---------------------------------
 427         -- Occcurrence INFO
 428 idOccInfo :: Id -> OccInfo
 429 idOccInfo id = occInfo (idInfo id)
 430
 431 setIdOccInfo :: Id -> OccInfo -> Id
 432 setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
 433 \end{code}
 434
 435
 436         ---------------------------------
 437         -- INLINING
 438 The inline pragma tells us to be very keen to inline this Id, but it's still
 439 OK not to if optimisation is switched off.
 440
 441 \begin{code}
 442 idInlinePragma :: Id -> InlinePragInfo
 443 idInlinePragma id = inlinePragInfo (idInfo id)
 444
 445 setInlinePragma :: Id -> InlinePragInfo -> Id
 446 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
 447
 448 modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
 449 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
 450 \end{code}
 451
 452
 453         ---------------------------------
 454         -- ONE-SHOT LAMBDAS
 455 \begin{code}
 456 idLBVarInfo :: Id -> LBVarInfo
 457 idLBVarInfo id = lbvarInfo (idInfo id)
 458
 459 isOneShotBndr :: Id -> Bool
 460 -- This one is the "business end", called externally.
 461 -- Its main purpose is to encapsulate the Horrible State Hack
 462 isOneShotBndr id = isOneShotLambda id || (isStateHack id)
 463
 464 isStateHack id
 465   | opt_NoStateHack
 466   = False
 467   | otherwise
 468   = case splitTyConApp_maybe (idType id) of
 469         Just (tycon,_) | tycon == statePrimTyCon -> True
 470         other                                    -> False
 471         -- This is a gross hack.  It claims that
 472         -- every function over realWorldStatePrimTy is a one-shot
 473         -- function.  This is pretty true in practice, and makes a big
 474         -- difference.  For example, consider
 475         --      a `thenST` \ r -> ...E...
 476         -- The early full laziness pass, if it doesn't know that r is one-shot
 477         -- will pull out E (let's say it doesn't mention r) to give
 478         --      let lvl = E in a `thenST` \ r -> ...lvl...
 479         -- When `thenST` gets inlined, we end up with
 480         --      let lvl = E in \s -> case a s of (r, s') -> ...lvl...
 481         -- and we don't re-inline E.
 482         --
 483         -- It would be better to spot that r was one-shot to start with, but
 484         -- I don't want to rely on that.
 485         --
 486         -- Another good example is in fill_in in PrelPack.lhs.  We should be able to
 487         -- spot that fill_in has arity 2 (and when Keith is done, we will) but we can't yet.
 488
 489
 490 -- The OneShotLambda functions simply fiddle with the IdInfo flag
 491 isOneShotLambda :: Id -> Bool
 492 isOneShotLambda id = case idLBVarInfo id of
 493                        IsOneShotLambda  -> True
 494                        NoLBVarInfo      -> False
 495
 496 setOneShotLambda :: Id -> Id
 497 setOneShotLambda id = modifyIdInfo (`setLBVarInfo` IsOneShotLambda) id
 498
 499 clearOneShotLambda :: Id -> Id
 500 clearOneShotLambda id
 501   | isOneShotLambda id = modifyIdInfo (`setLBVarInfo` NoLBVarInfo) id
 502   | otherwise          = id
 503
 504 -- But watch out: this may change the type of something else
 505 --      f = \x -> e
 506 -- If we change the one-shot-ness of x, f's type changes
 507 \end{code}
 508
 509 \begin{code}
 510 zapLamIdInfo :: Id -> Id
 511 zapLamIdInfo id = maybeModifyIdInfo zapLamInfo id
 512
 513 zapDemandIdInfo id = maybeModifyIdInfo zapDemandInfo id
 514 \end{code}
 515