2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[Id]{@Ids@: Value and constructor identifiers}
10 -- Simple construction
11 mkGlobalId, mkLocalId, mkSpecPragmaId, mkLocalIdWithInfo,
12 mkSysLocal, mkSysLocalUnencoded, mkUserLocal, mkVanillaGlobal,
13 mkTemplateLocals, mkTemplateLocalsNum, mkWildId, mkTemplateLocal,
14 mkWorkerId, mkExportedLocalId,
17 idName, idType, idUnique, idInfo,
18 isId, globalIdDetails, idPrimRep,
19 recordSelectorFieldLabel,
22 setIdName, setIdUnique, Id.setIdType, setIdLocalExported,
23 setIdInfo, lazySetIdInfo, modifyIdInfo, maybeModifyIdInfo,
24 zapLamIdInfo, zapDemandIdInfo,
27 isImplicitId, isDeadBinder,
28 isSpecPragmaId, isExportedId, isLocalId, isGlobalId,
30 isPrimOpId, isPrimOpId_maybe,
31 isFCallId, isFCallId_maybe,
32 isDataConWorkId, isDataConWorkId_maybe,
33 isBottomingId, idIsFrom,
36 -- Inline pragma stuff
37 idInlinePragma, setInlinePragma, modifyInlinePragma,
40 -- One shot lambda stuff
41 isOneShotBndr, isOneShotLambda, isStateHackType,
42 setOneShotLambda, clearOneShotLambda,
48 setIdNewStrictness, zapIdNewStrictness,
64 idNewDemandInfo, idNewDemandInfo_maybe,
65 idNewStrictness, idNewStrictness_maybe,
68 idSpecialisation, idCoreRules,
74 newStrictnessFromOld -- Temporary
79 #include "HsVersions.h"
82 import CoreSyn ( Unfolding, CoreRules, IdCoreRule, rulesRules )
83 import BasicTypes ( Arity )
84 import Var ( Id, DictId,
85 isId, isExportedId, isSpecPragmaId, isLocalId,
86 idName, idType, idUnique, idInfo, isGlobalId,
87 setIdName, setIdType, setIdUnique, setIdLocalExported,
88 setIdInfo, lazySetIdInfo, modifyIdInfo,
92 import qualified Var ( mkLocalId, mkGlobalId, mkSpecPragmaId, mkExportedLocalId )
93 import Type ( Type, typePrimRep, addFreeTyVars, seqType,
94 splitTyConApp_maybe, PrimRep )
95 import TysPrim ( statePrimTyCon )
99 import qualified Demand ( Demand )
101 import DataCon ( isUnboxedTupleCon )
102 import NewDemand ( Demand, StrictSig, topDmd, topSig, isBottomingSig )
103 import Name ( Name, OccName, nameIsLocalOrFrom,
104 mkSystemName, mkSystemNameEncoded, mkInternalName,
105 getOccName, getSrcLoc
107 import Module ( Module )
108 import OccName ( EncodedFS, mkWorkerOcc )
109 import FieldLabel ( FieldLabel )
110 import Maybes ( orElse )
111 import SrcLoc ( SrcLoc )
113 import Unique ( Unique, mkBuiltinUnique )
114 import CmdLineOpts ( opt_NoStateHack )
116 -- infixl so you can say (id `set` a `set` b)
117 infixl 1 `setIdUnfolding`,
119 `setIdNewDemandInfo`,
120 `setIdNewStrictness`,
122 `setIdSpecialisation`,
125 #ifdef OLD_STRICTNESS
134 %************************************************************************
136 \subsection{Simple Id construction}
138 %************************************************************************
140 Absolutely all Ids are made by mkId. It is just like Var.mkId,
141 but in addition it pins free-tyvar-info onto the Id's type,
142 where it can easily be found.
145 mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id
146 mkLocalIdWithInfo name ty info = Var.mkLocalId name (addFreeTyVars ty) info
148 mkSpecPragmaId :: Name -> Type -> Id
149 mkSpecPragmaId name ty = Var.mkSpecPragmaId name (addFreeTyVars ty) vanillaIdInfo
151 mkExportedLocalId :: Name -> Type -> Id
152 mkExportedLocalId name ty = Var.mkExportedLocalId name (addFreeTyVars ty) vanillaIdInfo
154 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
155 mkGlobalId details name ty info = Var.mkGlobalId details name (addFreeTyVars ty) info
159 mkLocalId :: Name -> Type -> Id
160 mkLocalId name ty = mkLocalIdWithInfo name ty vanillaIdInfo
162 -- SysLocal: for an Id being created by the compiler out of thin air...
163 -- UserLocal: an Id with a name the user might recognize...
164 mkUserLocal :: OccName -> Unique -> Type -> SrcLoc -> Id
165 mkSysLocal :: EncodedFS -> Unique -> Type -> Id
166 mkVanillaGlobal :: Name -> Type -> IdInfo -> Id
168 -- for SysLocal, we assume the base name is already encoded, to avoid
169 -- re-encoding the same string over and over again.
170 mkSysLocal fs uniq ty = mkLocalId (mkSystemNameEncoded uniq fs) ty
172 -- version to use when the faststring needs to be encoded
173 mkSysLocalUnencoded fs uniq ty = mkLocalId (mkSystemName uniq fs) ty
175 mkUserLocal occ uniq ty loc = mkLocalId (mkInternalName uniq occ loc) ty
176 mkVanillaGlobal = mkGlobalId VanillaGlobal
179 Make some local @Ids@ for a template @CoreExpr@. These have bogus
180 @Uniques@, but that's OK because the templates are supposed to be
181 instantiated before use.
184 -- "Wild Id" typically used when you need a binder that you don't expect to use
185 mkWildId :: Type -> Id
186 mkWildId ty = mkSysLocal FSLIT("wild") (mkBuiltinUnique 1) ty
188 mkWorkerId :: Unique -> Id -> Type -> Id
189 -- A worker gets a local name. CoreTidy will externalise it if necessary.
190 mkWorkerId uniq unwrkr ty
191 = mkLocalId wkr_name ty
193 wkr_name = mkInternalName uniq (mkWorkerOcc (getOccName unwrkr)) (getSrcLoc unwrkr)
195 -- "Template locals" typically used in unfoldings
196 mkTemplateLocals :: [Type] -> [Id]
197 mkTemplateLocals tys = zipWith mkTemplateLocal [1..] tys
199 mkTemplateLocalsNum :: Int -> [Type] -> [Id]
200 -- The Int gives the starting point for unique allocation
201 mkTemplateLocalsNum n tys = zipWith mkTemplateLocal [n..] tys
203 mkTemplateLocal :: Int -> Type -> Id
204 mkTemplateLocal i ty = mkSysLocal FSLIT("tpl") (mkBuiltinUnique i) ty
208 %************************************************************************
210 \subsection[Id-general-funs]{General @Id@-related functions}
212 %************************************************************************
215 setIdType :: Id -> Type -> Id
216 -- Add free tyvar info to the type
217 setIdType id ty = seqType ty `seq` Var.setIdType id (addFreeTyVars ty)
219 idPrimRep :: Id -> PrimRep
220 idPrimRep id = typePrimRep (idType id)
224 %************************************************************************
226 \subsection{Special Ids}
228 %************************************************************************
230 The @SpecPragmaId@ exists only to make Ids that are
231 on the *LHS* of bindings created by SPECIALISE pragmas;
233 The SpecPragmaId is never itself mentioned; it
234 exists solely so that the specialiser will find
235 the call to f, and make specialised version of it.
236 The SpecPragmaId binding is discarded by the specialiser
237 when it gathers up overloaded calls.
238 Meanwhile, it is not discarded as dead code.
242 recordSelectorFieldLabel :: Id -> FieldLabel
243 recordSelectorFieldLabel id = case globalIdDetails id of
244 RecordSelId lbl -> lbl
245 other -> panic "recordSelectorFieldLabel"
247 isRecordSelector id = case globalIdDetails id of
248 RecordSelId lbl -> True
251 isPrimOpId id = case globalIdDetails id of
255 isPrimOpId_maybe id = case globalIdDetails id of
256 PrimOpId op -> Just op
259 isFCallId id = case globalIdDetails id of
263 isFCallId_maybe id = case globalIdDetails id of
264 FCallId call -> Just call
267 isDataConWorkId id = case globalIdDetails id of
268 DataConWorkId _ -> True
271 isDataConWorkId_maybe id = case globalIdDetails id of
272 DataConWorkId con -> Just con
275 -- hasNoBinding returns True of an Id which may not have a
276 -- binding, even though it is defined in this module.
277 -- Data constructor workers used to be things of this kind, but
278 -- they aren't any more. Instead, we inject a binding for
279 -- them at the CorePrep stage.
280 -- EXCEPT: unboxed tuples, which definitely have no binding
281 hasNoBinding id = case globalIdDetails id of
284 DataConWorkId dc -> isUnboxedTupleCon dc
287 isImplicitId :: Id -> Bool
288 -- isImplicitId tells whether an Id's info is implied by other
289 -- declarations, so we don't need to put its signature in an interface
290 -- file, even if it's mentioned in some other interface unfolding.
292 = case globalIdDetails id of
293 RecordSelId _ -> True
297 DataConWorkId _ -> True
298 DataConWrapId _ -> True
299 -- These are are implied by their type or class decl;
300 -- remember that all type and class decls appear in the interface file.
301 -- The dfun id is not an implicit Id; it must *not* be omitted, because
302 -- it carries version info for the instance decl
305 idIsFrom :: Module -> Id -> Bool
306 idIsFrom mod id = nameIsLocalOrFrom mod (idName id)
310 isDeadBinder :: Id -> Bool
311 isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
312 | otherwise = False -- TyVars count as not dead
316 %************************************************************************
318 \subsection{IdInfo stuff}
320 %************************************************************************
323 ---------------------------------
325 idArity :: Id -> Arity
326 idArity id = arityInfo (idInfo id)
328 setIdArity :: Id -> Arity -> Id
329 setIdArity id arity = modifyIdInfo (`setArityInfo` arity) id
331 #ifdef OLD_STRICTNESS
332 ---------------------------------
334 idStrictness :: Id -> StrictnessInfo
335 idStrictness id = strictnessInfo (idInfo id)
337 setIdStrictness :: Id -> StrictnessInfo -> Id
338 setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
341 -- isBottomingId returns true if an application to n args would diverge
342 isBottomingId :: Id -> Bool
343 isBottomingId id = isBottomingSig (idNewStrictness id)
345 idNewStrictness_maybe :: Id -> Maybe StrictSig
346 idNewStrictness :: Id -> StrictSig
348 idNewStrictness_maybe id = newStrictnessInfo (idInfo id)
349 idNewStrictness id = idNewStrictness_maybe id `orElse` topSig
351 setIdNewStrictness :: Id -> StrictSig -> Id
352 setIdNewStrictness id sig = modifyIdInfo (`setNewStrictnessInfo` Just sig) id
354 zapIdNewStrictness :: Id -> Id
355 zapIdNewStrictness id = modifyIdInfo (`setNewStrictnessInfo` Nothing) id
357 ---------------------------------
359 idWorkerInfo :: Id -> WorkerInfo
360 idWorkerInfo id = workerInfo (idInfo id)
362 setIdWorkerInfo :: Id -> WorkerInfo -> Id
363 setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
365 ---------------------------------
367 idUnfolding :: Id -> Unfolding
368 idUnfolding id = unfoldingInfo (idInfo id)
370 setIdUnfolding :: Id -> Unfolding -> Id
371 setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
373 #ifdef OLD_STRICTNESS
374 ---------------------------------
376 idDemandInfo :: Id -> Demand.Demand
377 idDemandInfo id = demandInfo (idInfo id)
379 setIdDemandInfo :: Id -> Demand.Demand -> Id
380 setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
383 idNewDemandInfo_maybe :: Id -> Maybe NewDemand.Demand
384 idNewDemandInfo :: Id -> NewDemand.Demand
386 idNewDemandInfo_maybe id = newDemandInfo (idInfo id)
387 idNewDemandInfo id = newDemandInfo (idInfo id) `orElse` NewDemand.topDmd
389 setIdNewDemandInfo :: Id -> NewDemand.Demand -> Id
390 setIdNewDemandInfo id dmd = modifyIdInfo (`setNewDemandInfo` Just dmd) id
392 ---------------------------------
394 idSpecialisation :: Id -> CoreRules
395 idSpecialisation id = specInfo (idInfo id)
397 idCoreRules :: Id -> [IdCoreRule]
398 idCoreRules id = [(id,rule) | rule <- rulesRules (idSpecialisation id)]
400 setIdSpecialisation :: Id -> CoreRules -> Id
401 setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
403 ---------------------------------
405 idCafInfo :: Id -> CafInfo
406 #ifdef OLD_STRICTNESS
407 idCafInfo id = case cgInfo (idInfo id) of
408 NoCgInfo -> pprPanic "idCafInfo" (ppr id)
409 info -> cgCafInfo info
411 idCafInfo id = cafInfo (idInfo id)
414 setIdCafInfo :: Id -> CafInfo -> Id
415 setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
417 ---------------------------------
419 #ifdef OLD_STRICTNESS
420 idCprInfo :: Id -> CprInfo
421 idCprInfo id = cprInfo (idInfo id)
423 setIdCprInfo :: Id -> CprInfo -> Id
424 setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
427 ---------------------------------
429 idOccInfo :: Id -> OccInfo
430 idOccInfo id = occInfo (idInfo id)
432 setIdOccInfo :: Id -> OccInfo -> Id
433 setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
437 ---------------------------------
439 The inline pragma tells us to be very keen to inline this Id, but it's still
440 OK not to if optimisation is switched off.
443 idInlinePragma :: Id -> InlinePragInfo
444 idInlinePragma id = inlinePragInfo (idInfo id)
446 setInlinePragma :: Id -> InlinePragInfo -> Id
447 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
449 modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
450 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
454 ---------------------------------
457 idLBVarInfo :: Id -> LBVarInfo
458 idLBVarInfo id = lbvarInfo (idInfo id)
460 isOneShotBndr :: Id -> Bool
461 -- This one is the "business end", called externally.
462 -- Its main purpose is to encapsulate the Horrible State Hack
463 isOneShotBndr id = isOneShotLambda id || (isStateHackType (idType id))
465 isStateHackType :: Type -> Bool
470 = case splitTyConApp_maybe ty of
471 Just (tycon,_) -> tycon == statePrimTyCon
473 -- This is a gross hack. It claims that
474 -- every function over realWorldStatePrimTy is a one-shot
475 -- function. This is pretty true in practice, and makes a big
476 -- difference. For example, consider
477 -- a `thenST` \ r -> ...E...
478 -- The early full laziness pass, if it doesn't know that r is one-shot
479 -- will pull out E (let's say it doesn't mention r) to give
480 -- let lvl = E in a `thenST` \ r -> ...lvl...
481 -- When `thenST` gets inlined, we end up with
482 -- let lvl = E in \s -> case a s of (r, s') -> ...lvl...
483 -- and we don't re-inline E.
485 -- It would be better to spot that r was one-shot to start with, but
486 -- I don't want to rely on that.
488 -- Another good example is in fill_in in PrelPack.lhs. We should be able to
489 -- spot that fill_in has arity 2 (and when Keith is done, we will) but we can't yet.
492 -- The OneShotLambda functions simply fiddle with the IdInfo flag
493 isOneShotLambda :: Id -> Bool
494 isOneShotLambda id = case idLBVarInfo id of
495 IsOneShotLambda -> True
498 setOneShotLambda :: Id -> Id
499 setOneShotLambda id = modifyIdInfo (`setLBVarInfo` IsOneShotLambda) id
501 clearOneShotLambda :: Id -> Id
502 clearOneShotLambda id
503 | isOneShotLambda id = modifyIdInfo (`setLBVarInfo` NoLBVarInfo) id
506 -- But watch out: this may change the type of something else
508 -- If we change the one-shot-ness of x, f's type changes
512 zapLamIdInfo :: Id -> Id
513 zapLamIdInfo id = maybeModifyIdInfo zapLamInfo id
515 zapDemandIdInfo id = maybeModifyIdInfo zapDemandInfo id