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, mkUserLocal, mkVanillaGlobal,
13 mkTemplateLocals, mkTemplateLocalsNum, mkWildId, mkTemplateLocal,
17 idName, idType, idUnique, idInfo,
18 idPrimRep, isId, globalIdDetails,
19 recordSelectorFieldLabel,
22 setIdName, setIdUnique, setIdType, setIdLocalExported, setGlobalIdDetails,
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 isDataConId, isDataConId_maybe,
33 isDataConWrapId, isDataConWrapId_maybe,
37 -- Inline pragma stuff
38 idInlinePragma, setInlinePragma, modifyInlinePragma,
41 -- One shot lambda stuff
42 isOneShotLambda, setOneShotLambda, clearOneShotLambda,
48 setIdNewStrictness, zapIdNewStrictness,
65 idNewDemandInfo, idNewDemandInfo_maybe,
66 idNewStrictness, idNewStrictness_maybe,
70 idSpecialisation, idCoreRules,
77 newStrictnessFromOld -- Temporary
82 #include "HsVersions.h"
85 import CoreSyn ( Unfolding, CoreRules, IdCoreRule, rulesRules )
86 import BasicTypes ( Arity )
87 import Var ( Id, DictId,
88 isId, isExportedId, isSpecPragmaId, isLocalId,
89 idName, idType, idUnique, idInfo, isGlobalId,
90 setIdName, setVarType, setIdUnique, setIdLocalExported,
91 setIdInfo, lazySetIdInfo, modifyIdInfo,
93 globalIdDetails, setGlobalIdDetails
95 import qualified Var ( mkLocalId, mkGlobalId, mkSpecPragmaId )
96 import Type ( Type, typePrimRep, addFreeTyVars,
97 usOnce, eqUsage, seqType, splitTyConApp_maybe )
101 import qualified Demand ( Demand )
102 import NewDemand ( Demand, StrictSig, topDmd, topSig, isBottomingSig )
103 import Name ( Name, OccName,
104 mkSystemName, mkInternalName,
105 getOccName, getSrcLoc
107 import OccName ( EncodedFS, mkWorkerOcc )
108 import PrimRep ( PrimRep )
109 import TysPrim ( statePrimTyCon )
110 import FieldLabel ( FieldLabel )
111 import Maybes ( orElse )
112 import SrcLoc ( SrcLoc )
114 import Unique ( Unique, mkBuiltinUnique )
116 -- infixl so you can say (id `set` a `set` b)
117 infixl 1 `setIdUnfolding`,
119 `setIdNewDemandInfo`,
120 `setIdNewStrictness`,
123 `setIdSpecialisation`,
126 #ifdef OLD_STRICTNESS
135 %************************************************************************
137 \subsection{Simple Id construction}
139 %************************************************************************
141 Absolutely all Ids are made by mkId. It is just like Var.mkId,
142 but in addition it pins free-tyvar-info onto the Id's type,
143 where it can easily be found.
146 mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id
147 mkLocalIdWithInfo name ty info = Var.mkLocalId name (addFreeTyVars ty) info
149 mkSpecPragmaId :: Name -> Type -> Id
150 mkSpecPragmaId name ty = Var.mkSpecPragmaId name (addFreeTyVars ty) vanillaIdInfo
152 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
153 mkGlobalId details name ty info = Var.mkGlobalId details name (addFreeTyVars ty) info
157 mkLocalId :: Name -> Type -> Id
158 mkLocalId name ty = mkLocalIdWithInfo name ty vanillaIdInfo
160 -- SysLocal: for an Id being created by the compiler out of thin air...
161 -- UserLocal: an Id with a name the user might recognize...
162 mkUserLocal :: OccName -> Unique -> Type -> SrcLoc -> Id
163 mkSysLocal :: EncodedFS -> Unique -> Type -> Id
164 mkVanillaGlobal :: Name -> Type -> IdInfo -> Id
166 -- for SysLocal, we assume the base name is already encoded, to avoid
167 -- re-encoding the same string over and over again.
168 mkSysLocal fs uniq ty = mkLocalId (mkSystemName uniq fs) ty
169 mkUserLocal occ uniq ty loc = mkLocalId (mkInternalName uniq occ loc) ty
170 mkVanillaGlobal = mkGlobalId VanillaGlobal
173 Make some local @Ids@ for a template @CoreExpr@. These have bogus
174 @Uniques@, but that's OK because the templates are supposed to be
175 instantiated before use.
178 -- "Wild Id" typically used when you need a binder that you don't expect to use
179 mkWildId :: Type -> Id
180 mkWildId ty = mkSysLocal FSLIT("wild") (mkBuiltinUnique 1) ty
182 mkWorkerId :: Unique -> Id -> Type -> Id
183 -- A worker gets a local name. CoreTidy will externalise it if necessary.
184 mkWorkerId uniq unwrkr ty
185 = mkLocalId wkr_name ty
187 wkr_name = mkInternalName uniq (mkWorkerOcc (getOccName unwrkr)) (getSrcLoc unwrkr)
189 -- "Template locals" typically used in unfoldings
190 mkTemplateLocals :: [Type] -> [Id]
191 mkTemplateLocals tys = zipWith mkTemplateLocal [1..] tys
193 mkTemplateLocalsNum :: Int -> [Type] -> [Id]
194 -- The Int gives the starting point for unique allocation
195 mkTemplateLocalsNum n tys = zipWith mkTemplateLocal [n..] tys
197 mkTemplateLocal :: Int -> Type -> Id
198 mkTemplateLocal i ty = mkSysLocal FSLIT("tpl") (mkBuiltinUnique i) ty
202 %************************************************************************
204 \subsection[Id-general-funs]{General @Id@-related functions}
206 %************************************************************************
209 setIdType :: Id -> Type -> Id
210 -- Add free tyvar info to the type
211 setIdType id ty = seqType ty `seq` setVarType id (addFreeTyVars ty)
213 idPrimRep :: Id -> PrimRep
214 idPrimRep id = typePrimRep (idType id)
218 %************************************************************************
220 \subsection{Special Ids}
222 %************************************************************************
224 The @SpecPragmaId@ exists only to make Ids that are
225 on the *LHS* of bindings created by SPECIALISE pragmas;
227 The SpecPragmaId is never itself mentioned; it
228 exists solely so that the specialiser will find
229 the call to f, and make specialised version of it.
230 The SpecPragmaId binding is discarded by the specialiser
231 when it gathers up overloaded calls.
232 Meanwhile, it is not discarded as dead code.
236 recordSelectorFieldLabel :: Id -> FieldLabel
237 recordSelectorFieldLabel id = case globalIdDetails id of
238 RecordSelId lbl -> lbl
240 isRecordSelector id = case globalIdDetails id of
241 RecordSelId lbl -> True
244 isPrimOpId id = case globalIdDetails id of
248 isPrimOpId_maybe id = case globalIdDetails id of
249 PrimOpId op -> Just op
252 isFCallId id = case globalIdDetails id of
256 isFCallId_maybe id = case globalIdDetails id of
257 FCallId call -> Just call
260 isDataConId id = case globalIdDetails id of
264 isDataConId_maybe id = case globalIdDetails id of
265 DataConId con -> Just con
268 isDataConWrapId_maybe id = case globalIdDetails id of
269 DataConWrapId con -> Just con
272 isDataConWrapId id = case globalIdDetails id of
273 DataConWrapId con -> True
276 -- hasNoBinding returns True of an Id which may not have a
277 -- binding, even though it is defined in this module.
278 -- Data constructor workers used to be things of this kind, but
279 -- they aren't any more. Instead, we inject a binding for
280 -- them at the CorePrep stage.
281 hasNoBinding id = case globalIdDetails id of
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.
291 = case globalIdDetails id of
292 RecordSelId _ -> True -- Includes dictionary selectors
296 DataConWrapId _ -> True
297 -- These are are implied by their type or class decl;
298 -- remember that all type and class decls appear in the interface file.
299 -- The dfun id must *not* be omitted, because it carries version info for
305 isDeadBinder :: Id -> Bool
306 isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
307 | otherwise = False -- TyVars count as not dead
311 %************************************************************************
313 \subsection{IdInfo stuff}
315 %************************************************************************
318 ---------------------------------
320 idArity :: Id -> Arity
321 idArity id = arityInfo (idInfo id)
323 setIdArity :: Id -> Arity -> Id
324 setIdArity id arity = modifyIdInfo (`setArityInfo` arity) id
326 #ifdef OLD_STRICTNESS
327 ---------------------------------
329 idStrictness :: Id -> StrictnessInfo
330 idStrictness id = strictnessInfo (idInfo id)
332 setIdStrictness :: Id -> StrictnessInfo -> Id
333 setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
336 -- isBottomingId returns true if an application to n args would diverge
337 isBottomingId :: Id -> Bool
338 isBottomingId id = isBottomingSig (idNewStrictness id)
340 idNewStrictness_maybe :: Id -> Maybe StrictSig
341 idNewStrictness :: Id -> StrictSig
343 idNewStrictness_maybe id = newStrictnessInfo (idInfo id)
344 idNewStrictness id = idNewStrictness_maybe id `orElse` topSig
346 setIdNewStrictness :: Id -> StrictSig -> Id
347 setIdNewStrictness id sig = modifyIdInfo (`setNewStrictnessInfo` Just sig) id
349 zapIdNewStrictness :: Id -> Id
350 zapIdNewStrictness id = modifyIdInfo (`setNewStrictnessInfo` Nothing) id
352 ---------------------------------
353 -- TYPE GENERALISATION
354 idTyGenInfo :: Id -> TyGenInfo
355 idTyGenInfo id = tyGenInfo (idInfo id)
357 setIdTyGenInfo :: Id -> TyGenInfo -> Id
358 setIdTyGenInfo id tygen_info = modifyIdInfo (`setTyGenInfo` tygen_info) id
360 ---------------------------------
362 idWorkerInfo :: Id -> WorkerInfo
363 idWorkerInfo id = workerInfo (idInfo id)
365 setIdWorkerInfo :: Id -> WorkerInfo -> Id
366 setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
368 ---------------------------------
370 idUnfolding :: Id -> Unfolding
371 idUnfolding id = unfoldingInfo (idInfo id)
373 setIdUnfolding :: Id -> Unfolding -> Id
374 setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
376 #ifdef OLD_STRICTNESS
377 ---------------------------------
379 idDemandInfo :: Id -> Demand.Demand
380 idDemandInfo id = demandInfo (idInfo id)
382 setIdDemandInfo :: Id -> Demand.Demand -> Id
383 setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
386 idNewDemandInfo_maybe :: Id -> Maybe NewDemand.Demand
387 idNewDemandInfo :: Id -> NewDemand.Demand
389 idNewDemandInfo_maybe id = newDemandInfo (idInfo id)
390 idNewDemandInfo id = newDemandInfo (idInfo id) `orElse` NewDemand.topDmd
392 setIdNewDemandInfo :: Id -> NewDemand.Demand -> Id
393 setIdNewDemandInfo id dmd = modifyIdInfo (`setNewDemandInfo` Just dmd) id
395 ---------------------------------
397 idSpecialisation :: Id -> CoreRules
398 idSpecialisation id = specInfo (idInfo id)
400 idCoreRules :: Id -> [IdCoreRule]
401 idCoreRules id = [(id,rule) | rule <- rulesRules (idSpecialisation id)]
403 setIdSpecialisation :: Id -> CoreRules -> Id
404 setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
406 ---------------------------------
408 idCgInfo :: Id -> CgInfo
409 #ifdef OLD_STRICTNESS
410 idCgInfo id = case cgInfo (idInfo id) of
411 NoCgInfo -> pprPanic "idCgInfo" (ppr id)
414 idCgInfo id = cgInfo (idInfo id)
417 setIdCgInfo :: Id -> CgInfo -> Id
418 setIdCgInfo id cg_info = modifyIdInfo (`setCgInfo` cg_info) id
420 ---------------------------------
422 idCafInfo :: Id -> CafInfo
423 #ifdef OLD_STRICTNESS
424 idCafInfo id = case cgInfo (idInfo id) of
425 NoCgInfo -> pprPanic "idCafInfo" (ppr id)
426 info -> cgCafInfo info
428 idCafInfo id = cgCafInfo (idCgInfo id)
430 ---------------------------------
432 #ifdef OLD_STRICTNESS
433 idCprInfo :: Id -> CprInfo
434 idCprInfo id = cprInfo (idInfo id)
436 setIdCprInfo :: Id -> CprInfo -> Id
437 setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
440 ---------------------------------
442 idOccInfo :: Id -> OccInfo
443 idOccInfo id = occInfo (idInfo id)
445 setIdOccInfo :: Id -> OccInfo -> Id
446 setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
450 ---------------------------------
452 The inline pragma tells us to be very keen to inline this Id, but it's still
453 OK not to if optimisation is switched off.
456 idInlinePragma :: Id -> InlinePragInfo
457 idInlinePragma id = inlinePragInfo (idInfo id)
459 setInlinePragma :: Id -> InlinePragInfo -> Id
460 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
462 modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
463 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
467 ---------------------------------
470 idLBVarInfo :: Id -> LBVarInfo
471 idLBVarInfo id = lbvarInfo (idInfo id)
473 isOneShotLambda :: Id -> Bool
474 isOneShotLambda id = analysis || hack
475 where analysis = case idLBVarInfo id of
476 LBVarInfo u | u `eqUsage` usOnce -> True
478 hack = case splitTyConApp_maybe (idType id) of
479 Just (tycon,_) | tycon == statePrimTyCon -> True
482 -- The last clause is a gross hack. It claims that
483 -- every function over realWorldStatePrimTy is a one-shot
484 -- function. This is pretty true in practice, and makes a big
485 -- difference. For example, consider
486 -- a `thenST` \ r -> ...E...
487 -- The early full laziness pass, if it doesn't know that r is one-shot
488 -- will pull out E (let's say it doesn't mention r) to give
489 -- let lvl = E in a `thenST` \ r -> ...lvl...
490 -- When `thenST` gets inlined, we end up with
491 -- let lvl = E in \s -> case a s of (r, s') -> ...lvl...
492 -- and we don't re-inline E.
494 -- It would be better to spot that r was one-shot to start with, but
495 -- I don't want to rely on that.
497 -- Another good example is in fill_in in PrelPack.lhs. We should be able to
498 -- spot that fill_in has arity 2 (and when Keith is done, we will) but we can't yet.
500 setOneShotLambda :: Id -> Id
501 setOneShotLambda id = modifyIdInfo (`setLBVarInfo` LBVarInfo usOnce) id
503 clearOneShotLambda :: Id -> Id
504 clearOneShotLambda id
505 | isOneShotLambda id = modifyIdInfo (`setLBVarInfo` NoLBVarInfo) id
508 -- But watch out: this may change the type of something else
510 -- If we change the one-shot-ness of x, f's type changes
514 zapLamIdInfo :: Id -> Id
515 zapLamIdInfo id = maybeModifyIdInfo zapLamInfo id
517 zapDemandIdInfo id = maybeModifyIdInfo zapDemandInfo id