... | ... | @@ -28,10 +28,9 @@ Principles |
|
|
Tasks
|
|
|
=====
|
|
|
|
|
|
Make the pipeline apparent in the module hierarchy (#13009)
|
|
|
-----------------------------------------------------------
|
|
|
- [X] Make the pipeline apparent in the module hierarchy
|
|
|
|
|
|
We would like to introduce the following module prefixes:
|
|
|
This has been completed in GHC 8.12. See #13009 for the newer module names.
|
|
|
|
|
|
![ghc_modules.svg](uploads/db1b2a8fa23301b897a3e6f16dcefbab/ghc_modules.svg)
|
|
|
|
... | ... | @@ -49,661 +48,11 @@ Goals: |
|
|
* Ensure that each IR can be used independently from the others
|
|
|
* Improve the generated Haddocks (table of contents reflecting the hierarchy)
|
|
|
|
|
|
### Proposed renaming
|
|
|
-----------------
|
|
|
|
|
|
* `GHC.Hs`
|
|
|
|
|
|
```
|
|
|
GHC.Hs.Binds <= hsSyn/HsBinds.hs
|
|
|
GHC.Hs.Decls <= hsSyn/HsDecls.hs
|
|
|
GHC.Hs.Doc <= hsSyn/HsDoc.hs
|
|
|
GHC.Hs.Dump <= hsSyn/HsDumpAst.hs
|
|
|
GHC.Hs.Expr <= hsSyn/HsExpr.hs
|
|
|
GHC.Hs.Extension <= hsSyn/HsExtension.hs
|
|
|
GHC.Hs <= hsSyn/HsSyn.hs
|
|
|
GHC.Hs.ImpExp <= hsSyn/HsImpExp.hs
|
|
|
GHC.Hs.Instances <= hsSyn/HsInstances.hs
|
|
|
GHC.Hs.Lit <= hsSyn/HsLit.hs
|
|
|
GHC.Hs.Pat <= hsSyn/HsPat.hs
|
|
|
GHC.Hs.PlaceHolder <= hsSyn/PlaceHolder.hs
|
|
|
GHC.Hs.Types <= hsSyn/HsTypes.hs
|
|
|
GHC.Hs.Utils <= hsSyn/HsUtils.hs
|
|
|
GHC.Hs.Stats <= main/HscStats.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.Platform`
|
|
|
```
|
|
|
GHC.Platform.ARM64 <= codeGen/CodeGen/Platform/ARM64.hs
|
|
|
GHC.Platform.ARM <= codeGen/CodeGen/Platform/ARM.hs
|
|
|
GHC.Platform.NoRegs <= codeGen/CodeGen/Platform/NoRegs.hs
|
|
|
GHC.Platform.PPC <= codeGen/CodeGen/Platform/PPC.hs
|
|
|
GHC.Platform.Regs <= codeGen/CodeGen/Platform.hs
|
|
|
GHC.Platform.SPARC <= codeGen/CodeGen/Platform/SPARC.hs
|
|
|
GHC.Platform.X86_64 <= codeGen/CodeGen/Platform/X86_64.hs
|
|
|
GHC.Platform.X86 <= codeGen/CodeGen/Platform/X86.hs
|
|
|
```
|
|
|
* `GHC.StgToCmm`
|
|
|
```
|
|
|
GHC.StgToCmm.ArgRep <= codeGen/StgCmmArgRep.hs
|
|
|
GHC.StgToCmm.Bind <= codeGen/StgCmmBind.hs
|
|
|
GHC.StgToCmm.CgUtils <= codeGen/CgUtils.hs
|
|
|
GHC.StgToCmm.Closure <= codeGen/StgCmmClosure.hs
|
|
|
GHC.StgToCmm.DataCon <= codeGen/StgCmmCon.hs
|
|
|
GHC.StgToCmm.Env <= codeGen/StgCmmEnv.hs
|
|
|
GHC.StgToCmm.Expr <= codeGen/StgCmmExpr.hs
|
|
|
GHC.StgToCmm.ExtCode <= codeGen/StgCmmExtCode.hs
|
|
|
GHC.StgToCmm.Foreign <= codeGen/StgCmmForeign.hs
|
|
|
GHC.StgToCmm.Heap <= codeGen/StgCmmHeap.hs
|
|
|
GHC.StgToCmm.Hpc <= codeGen/StgCmmHpc.hs
|
|
|
GHC.StgToCmm <= codeGen/StgCmm.hs
|
|
|
GHC.StgToCmm.Layout <= codeGen/StgCmmLayout.hs
|
|
|
GHC.StgToCmm.Monad <= codeGen/StgCmmMonad.hs
|
|
|
GHC.StgToCmm.Prim <= codeGen/StgCmmPrim.hs
|
|
|
GHC.StgToCmm.Prof <= codeGen/StgCmmProf.hs
|
|
|
GHC.StgToCmm.Ticky <= codeGen/StgCmmTicky.hs
|
|
|
GHC.StgToCmm.Utils <= codeGen/StgCmmUtils.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.ThToHs`
|
|
|
|
|
|
```
|
|
|
GHC.ThToHs <= hsSync/Convert.hs
|
|
|
```
|
|
|
|
|
|
* Renamer !1899:
|
|
|
|
|
|
|
|
|
```
|
|
|
GHC.Rename.Bind <= rename/RnBinds.hs
|
|
|
GHC.Rename.Env <= rename/RnEnv.hs
|
|
|
GHC.Rename.Expr <= rename/RnExpr.hs
|
|
|
GHC.Rename.Fixity <= rename/RnFixity.hs
|
|
|
GHC.Rename.Doc <= rename/RnHsDoc.hs
|
|
|
GHC.Rename.Names <= rename/RnNames.hs
|
|
|
GHC.Rename.Pat <= rename/RnPat.hs
|
|
|
GHC.Rename.Module <= rename/RnSource.hs
|
|
|
GHC.Rename.Splice <= rename/RnSplice.hs
|
|
|
GHC.Rename.HsType <= rename/RnTypes.hs
|
|
|
GHC.Rename.Unbound <= rename/RnUnbound.hs
|
|
|
GHC.Rename.Utils <= rename/RnUtils.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.Core` !1773:
|
|
|
|
|
|
```
|
|
|
GHC.Core.Arity <= coreSyn/CoreArity.hs
|
|
|
GHC.Core.FVs <= coreSyn/CoreFVs.hs
|
|
|
GHC.Core.Map <= coreSyn/CoreMap.hs
|
|
|
GHC.Core.SimpleOpt <= coreSyn/CoreOpt.hs
|
|
|
GHC.Core.Seq <= coreSyn/CoreSeq.hs
|
|
|
GHC.Core.Stats <= coreSyn/CoreStats.hs
|
|
|
GHC.Core.Subst <= coreSyn/CoreSubst.hs
|
|
|
GHC.Core <= coreSyn/CoreSyn.hs
|
|
|
GHC.Core.Unfold <= coreSyn/CoreUnfold.hs
|
|
|
GHC.Core.Utils <= coreSyn/CoreUtils.hs
|
|
|
GHC.Core.Make <= coreSyn/MkCore.hs
|
|
|
GHC.Core.Ppr <= coreSyn/PprCore.hs
|
|
|
GHC.Core.Ppr.TyThing <= main/PprTyThing.hs
|
|
|
GHC.Core.Rules <= specialise/Rules.hs
|
|
|
GHC.Core.Lint <= coreSyn/CoreLint.hs
|
|
|
|
|
|
GHC.Core.Class <= types/Class.hs
|
|
|
GHC.Core.Coercion <= types/Coercion.hs
|
|
|
GHC.Core.ConLike <= basicTypes/ConLike.hs
|
|
|
GHC.Core.FamInstEnv <= types/FamInstEnv.hs
|
|
|
GHC.Core.InstEnv <= types/InstEnv.hs
|
|
|
GHC.Core.TyCon <= types/TyCon.hs
|
|
|
GHC.Core.Type <= types/Type.hs
|
|
|
GHC.Core.Unify <= types/Unify.hs
|
|
|
GHC.Core.DataCon <= basicTypes/DataCon.hs
|
|
|
GHC.Core.PatSyn <= basicTypes/PatSyn.hs
|
|
|
GHC.Core.Predicate <= basicTypes/Predicate.hs
|
|
|
|
|
|
GHC.Core.TyCo.FVs <= types/TyCoFVs.hs
|
|
|
GHC.Core.TyCo.Ppr <= types/TyCoPpr.hs
|
|
|
GHC.Core.TyCo.Rep <= types/TyCoRep.hs
|
|
|
GHC.Core.TyCo.Subst <= types/TyCoSubst.hs
|
|
|
GHC.Core.TyCo.Tidy <= types/TyCoTidy.hs
|
|
|
|
|
|
GHC.Core.Coercion.Axiom <= types/CoAxiom.hs
|
|
|
GHC.Core.Coercion.Opt <= types/OptCoercion.hs
|
|
|
|
|
|
GHC.Core.Op.CallArity <= simplCore/CallArity.hs
|
|
|
GHC.Core.Op.Monad <= simplCore/CoreMonad.hs
|
|
|
GHC.Core.Op.CSE <= simplCore/CSE.hs
|
|
|
GHC.Core.Op.Exitify <= simplCore/Exitify.hs
|
|
|
GHC.Core.Op.FloatIn <= simplCore/FloatIn.hs
|
|
|
GHC.Core.Op.FloatOut <= simplCore/FloatOut.hs
|
|
|
GHC.Core.Op.LiberateCase <= simplCore/LiberateCase.hs
|
|
|
GHC.Core.Op.OccurAnal <= simplCore/OccurAnal.hs
|
|
|
GHC.Core.Op.StaticArgs <= simplCore/SAT.hs
|
|
|
GHC.Core.Op.SetLevels <= simplCore/SetLevels.hs
|
|
|
GHC.Core.Op.Simplify.Driver <= simplCore/SimplCore.hs
|
|
|
GHC.Core.Op.Simplify.Env <= simplCore/SimplEnv.hs
|
|
|
GHC.Core.Op.Simplify <= simplCore/Simplify.hs
|
|
|
GHC.Core.Op.Simplify.Monad <= simplCore/SimplMonad.hs
|
|
|
GHC.Core.Op.Simplify.Utils <= simplCore/SimplUtils.hs
|
|
|
GHC.Core.Op.SpecConstr <= specialise/SpecConstr.hs
|
|
|
GHC.Core.Op.Specialise <= specialise/Specialise.hs
|
|
|
GHC.Core.Op.DmdAnal <= stranal/DmdAnal.hs
|
|
|
GHC.Core.Op.WorkWrap <= stranal/WorkWrap.hs
|
|
|
GHC.Core.Op.WorkWrap.Lib <= stranal/WwLib.hs
|
|
|
GHC.Core.Op.ConstantFold <= prelude/PrelRules.hs
|
|
|
GHC.Core.Op.Tidy <= coreSyn/CoreTidy.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.Types`:
|
|
|
```
|
|
|
GHC.Types.Annotation <= main/Annotations.hs
|
|
|
GHC.Types.Avail <= basicTypes/Avail.hs
|
|
|
GHC.Types.Basic <= basicTypes/BasicTypes.hs
|
|
|
GHC.Types.Cpr <= basicTypes/Cpr.hs
|
|
|
GHC.Types.Demand <= basicTypes/Demand.hs
|
|
|
GHC.Types.FieldLabel <= basicTypes/FieldLabel.hs
|
|
|
GHC.Types.Literal <= basicTypes/Literal.hs
|
|
|
GHC.Types.Module <= basicTypes/Module.hs
|
|
|
GHC.Types.RepType <= simplStg/RepType.hs
|
|
|
GHC.Types.SrcLoc <= basicTypes/SrcLoc.hs
|
|
|
GHC.Types.ForeignCall <= prelude/ForeignCall.hs
|
|
|
|
|
|
GHC.Types.Var <= basicTypes/Var.hs
|
|
|
GHC.Types.Var.Set <= basicTypes/VarSet.hs
|
|
|
GHC.Types.Var.Env <= basicTypes/VarEnv.hs
|
|
|
|
|
|
GHC.Types.Id <= basicTypes/Id.hs
|
|
|
GHC.Types.Id.Info <= basicTypes/IdInfo.hs
|
|
|
GHC.Types.Id.Make <= basicTypes/MkId.hs
|
|
|
|
|
|
GHC.Types.Name <= basicTypes/Name.hs
|
|
|
GHC.Types.Name.Occurrence <= basicTypes/OccName.hs
|
|
|
GHC.Types.Name.Reader <= basicTypes/RdrName.hs
|
|
|
GHC.Types.Name.Set <= basicTypes/NameSet.hs
|
|
|
GHC.Types.Name.Shape <= backpack/NameShape.hs
|
|
|
GHC.Types.Name.Cache <= basicTypes/NameCache.hs
|
|
|
GHC.Types.Name.Env <= basicTypes/NameEnv.hs
|
|
|
|
|
|
GHC.Types.CostCentre <= profiling/CostCentre.hs
|
|
|
GHC.Types.CostCentre.State <= profiling/CostCentreState.hs
|
|
|
Merged into GHC.Driver.CodeOutput <= profiling/ProfInit.hs
|
|
|
|
|
|
GHC.Types.Unique <= basicTypes/Unique.hs
|
|
|
GHC.Types.Unique.Supply <= basicTypes/UniqSupply.hs
|
|
|
GHC.Types.Unique.DFM <= utils/UniqDFM.hs
|
|
|
GHC.Types.Unique.DSet <= utils/UniqDSet.hs
|
|
|
GHC.Types.Unique.FM <= utils/UniqFM.hs
|
|
|
GHC.Types.Unique.Set <= utils/UniqSet.hs
|
|
|
/dev/null <= utils/UniqMap.hs
|
|
|
|
|
|
GHC.Utils.Lexeme <= basicTypes/Lexeme.hs
|
|
|
```
|
|
|
|
|
|
|
|
|
* `GHC.Cmm`
|
|
|
|
|
|
```
|
|
|
GHC.Cmm.BlockId <= cmm/BlockId.hs
|
|
|
GHC.Cmm.CLabel <= cmm/CLabel.hs
|
|
|
GHC.Cmm.CallConv <= cmm/CmmCallConv.hs
|
|
|
GHC.Cmm.CommonBlockElim <= cmm/CmmCommonBlockElim.hs
|
|
|
GHC.Cmm.ContFlowOpt <= cmm/CmmContFlowOpt.hs
|
|
|
GHC.Cmm.Expr <= cmm/CmmExpr.hs
|
|
|
GHC.Cmm <= cmm/Cmm.hs
|
|
|
GHC.Cmm.Switch <= cmm/CmmSwitch.hs
|
|
|
GHC.Cmm.Switch.Implement <= cmm/CmmImplementSwitchPlans.hs
|
|
|
GHC.Cmm.Info <= cmm/CmmInfo.hs
|
|
|
GHC.Cmm.Info.Build <= cmm/CmmBuildInfoTables.hs
|
|
|
GHC.Cmm.LayoutStack <= cmm/CmmLayoutStack.hs
|
|
|
GHC.Cmm.Lint <= cmm/CmmLint.hs
|
|
|
GHC.Cmm.Liveness <= cmm/CmmLive.hs
|
|
|
GHC.Cmm.MachOp <= cmm/CmmMachOp.hs
|
|
|
GHC.Cmm.Monad <= cmm/CmmMonad.hs
|
|
|
GHC.Cmm.Node <= cmm/CmmNode.hs
|
|
|
GHC.Cmm.Opt <= cmm/CmmOpt.hs
|
|
|
GHC.Cmm.Pipeline <= cmm/CmmPipeline.hs
|
|
|
GHC.Cmm.ProcPoint <= cmm/CmmProcPoint.hs
|
|
|
GHC.Cmm.Sink <= cmm/CmmSink.hs
|
|
|
GHC.Cmm.Type <= cmm/CmmType.hs
|
|
|
GHC.Cmm.Utils <= cmm/CmmUtils.hs
|
|
|
GHC.Cmm.DebugBlock <= cmm/Debug.hs
|
|
|
GHC.Cmm.Dataflow.Block <= cmm/Hoopl/Block.hs
|
|
|
GHC.Cmm.Dataflow.Collections <= cmm/Hoopl/Collections.hs
|
|
|
GHC.Cmm.Dataflow <= cmm/Hoopl/Dataflow.hs
|
|
|
GHC.Cmm.Dataflow.Graph <= cmm/Hoopl/Graph.hs
|
|
|
GHC.Cmm.Dataflow.Label <= cmm/Hoopl/Label.hs
|
|
|
GHC.Cmm.Graph <= cmm/MkGraph.hs
|
|
|
GHC.Cmm.Ppr.Decl <= cmm/PprCmmDecl.hs
|
|
|
GHC.Cmm.Ppr.Expr <= cmm/PprCmmExpr.hs
|
|
|
GHC.Cmm.Ppr <= cmm/PprCmm.hs
|
|
|
GHC.Cmm.Lexer <= cmm/CmmLex.x
|
|
|
GHC.Cmm.Parser <= cmm/CmmParse.y
|
|
|
|
|
|
GHC.CmmToC <= cmm/PprC.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.Tc`
|
|
|
|
|
|
```
|
|
|
GHC.Tc.Deriv <= typecheck/TcDeriv.hs
|
|
|
GHC.Tc.Deriv.Infer <= typecheck/TcDerivInfer.hs
|
|
|
GHC.Tc.Deriv.Utils <= typecheck/TcDerivUtils.hs
|
|
|
GHC.Tc.Deriv.Generate <= typecheck/TcGenDeriv.hs
|
|
|
GHC.Tc.Deriv.Functor <= typecheck/TcGenFunctor.hs
|
|
|
GHC.Tc.Deriv.Generics <= typecheck/TcGenGenerics.hs
|
|
|
|
|
|
GHC.Tc.Solver <= typecheck/TcSimplify.hs
|
|
|
GHC.Tc.Solver.Interact <= typecheck/TcInteract.hs
|
|
|
GHC.Tc.Solver.Monad <= typecheck/TcSMonad.hs
|
|
|
GHC.Tc.Solver.Canonical <= typecheck/TcCanonical.hs
|
|
|
GHC.Tc.Solver.Flatten <= typecheck/TcFlatten.hs
|
|
|
|
|
|
GHC.Tc.Types <= typecheck/TcRnTypes.hs
|
|
|
GHC.Tc.Types.Constraint <= typecheck/Constraint.hs
|
|
|
GHC.Tc.Types.Origin <= typecheck/TcOrigin.hs
|
|
|
GHC.Tc.Types.Evidence <= typecheck/TcEvidence.hs
|
|
|
GHC.Tc.Types.EvTerm <= typecheck/TcEvTerm.hs
|
|
|
|
|
|
GHC.Tc.Utils.Backpack <= typecheck/TcBackpack.hs
|
|
|
GHC.Tc.Utils.Env <= typecheck/TcEnv.hs
|
|
|
GHC.Tc.Utils.Instantiate <= typecheck/Inst.hs
|
|
|
GHC.Tc.Utils.Monad <= typecheck/TcRnMonad.hs
|
|
|
GHC.Tc.Utils.TcMType <= typecheck/TcMType.hs
|
|
|
GHC.Tc.Utils.TcType <= typecheck/TcType.hs
|
|
|
GHC.Tc.Utils.Unify <= typecheck/TcUnify.hs
|
|
|
GHC.Tc.Utils.Zonk <= typecheck/TcHsSyn.hs
|
|
|
|
|
|
GHC.Tc.Instance.Class <= typecheck/ClsInst.hs
|
|
|
GHC.Tc.Instance.Family <= typecheck/FamInst.hs
|
|
|
GHC.Tc.Instance.Typeable <= typecheck/TcTypeable.hs
|
|
|
GHC.Tc.Instance.FunDeps <= typecheck/FunDeps.hs
|
|
|
|
|
|
GHC.Tc.Gen.Annotation <= typecheck/TcAnnotations.hs
|
|
|
GHC.Tc.Gen.Arrow <= typecheck/TcArrows.hs
|
|
|
GHC.Tc.Gen.Bind <= typecheck/TcBinds.hs
|
|
|
GHC.Tc.Gen.Default <= typecheck/TcDefaults.hs
|
|
|
GHC.Tc.Gen.Export <= typecheck/TcRnExports.hs
|
|
|
GHC.Tc.Gen.Expr <= typecheck/TcExpr.hs
|
|
|
GHC.Tc.Gen.Foreign <= typecheck/TcForeign.hs
|
|
|
GHC.Tc.Gen.HsType <= typecheck/TcHsType.hs
|
|
|
GHC.Tc.Gen.Match <= typecheck/TcMatches.hs
|
|
|
GHC.Tc.Gen.Pat <= typecheck/TcPat.hs
|
|
|
GHC.Tc.Gen.Rule <= typecheck/TcRules.hs
|
|
|
GHC.Tc.Gen.Sig <= typecheck/TcSigs.hs
|
|
|
GHC.Tc.Gen.Splice <= typecheck/TcSplice.hs
|
|
|
|
|
|
GHC.Tc.Errors <= typecheck/TcErrors.hs
|
|
|
GHC.Tc.Errors.Hole <= typecheck/TcHoleErrors.hs
|
|
|
GHC.Tc.Errors.Hole.FitTypes <= typecheck/TcHoleFitTypes.hs
|
|
|
|
|
|
GHC.Tc.TyCl <= typecheck/TcTyClsDecls.hs
|
|
|
GHC.Tc.TyCl.Build <= iface/BuildTyCl.hs
|
|
|
GHC.Tc.TyCl.Class <= typecheck/TcClassDcl.hs
|
|
|
GHC.Tc.TyCl.Instance <= typecheck/TcInstDcls.hs
|
|
|
GHC.Tc.TyCl.PatSyn <= typecheck/TcPatSyn.hs
|
|
|
GHC.Tc.TyCl.Utils <= typecheck/TcTyDecls.hs
|
|
|
|
|
|
GHC.Tc.Module <= typecheck/TcRnDriver.hs
|
|
|
GHC.Tc.Validity <= typecheck/TcValidity.hs
|
|
|
GHC.Tc.Plugin <= typecheck/TcPluginM.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.HsToCore`
|
|
|
|
|
|
```
|
|
|
GHC.HsToCore.PmCheck <= deSugar/Check.hs
|
|
|
GHC.HsToCore.PmCheck.Oracle <= deSugar/PmOracle.hs
|
|
|
GHC.HsToCore.PmCheck.Ppr <= deSugar/PmPpr.hs
|
|
|
GHC.HsToCore.PmCheck.Types <= deSugar/PmTypes.hs
|
|
|
|
|
|
GHC.HsToCore <= deSugar/Desugar.hs
|
|
|
GHC.HsToCore.Coverage <= deSugar/Coverage.hs
|
|
|
GHC.HsToCore.Arrows <= deSugar/DsArrows.hs
|
|
|
GHC.HsToCore.Binds <= deSugar/DsBinds.hs
|
|
|
GHC.HsToCore.Foreign.Call <= deSugar/DsCCall.hs
|
|
|
GHC.HsToCore.Foreign.Decl <= deSugar/DsForeign.hs
|
|
|
GHC.HsToCore.Expr <= deSugar/DsExpr.hs
|
|
|
GHC.HsToCore.GuardedRHSs <= deSugar/DsGRHSs.hs
|
|
|
GHC.HsToCore.ListComp <= deSugar/DsListComp.hs
|
|
|
GHC.HsToCore.Quote <= deSugar/DsMeta.hs
|
|
|
GHC.HsToCore.Monad <= deSugar/DsMonad.hs
|
|
|
GHC.HsToCore.Usage <= deSugar/DsUsage.hs
|
|
|
GHC.HsToCore.Utils <= deSugar/DsUtils.hs
|
|
|
GHC.HsToCore.Docs <= deSugar/ExtractDocs.hs
|
|
|
GHC.HsToCore.Match <= deSugar/Match.hs
|
|
|
GHC.HsToCore.Match.Constructor <= deSugar/MatchCon.hs
|
|
|
GHC.HsToCore.Match.Literal <= deSugar/MatchLit.hs
|
|
|
```
|
|
|
|
|
|
* Stg
|
|
|
|
|
|
```
|
|
|
GHC.Stg.Pipeline <= simplStg/SimplStg.hs
|
|
|
GHC.Stg.CSE <= simplStg/StgCse.hs
|
|
|
GHC.Stg.Stats <= simplStg/StgStats.hs
|
|
|
GHC.Stg.Unarise <= simplStg/UnariseStg.hs
|
|
|
GHC.Stg.FVs <= stgSyn/StgFVs.hs
|
|
|
GHC.Stg.Lint <= stgSyn/StgLint.hs
|
|
|
GHC.Stg.Subst <= stgSyn/StgSubst.hs
|
|
|
GHC.Stg.Syntax <= stgSyn/StgSyn.hs
|
|
|
|
|
|
GHC.Stg.Lift <= simplStg/StgLiftLams.hs merged with simplStg/StgLiftLams/Transformation.hs
|
|
|
GHC.Stg.Lift.Analysis <= simplStg/StgLiftLams/Analysis.hs
|
|
|
GHC.Stg.Lift.Monad <= simplStg/StgLiftLams/LiftM.hs
|
|
|
|
|
|
GHC.CoreToStg <= stgSyn/CoreToStg.hs
|
|
|
GHC.CoreToStg.Prep <= coreSyn/CorePrep.hs
|
|
|
```
|
|
|
|
|
|
* Builtin
|
|
|
|
|
|
```
|
|
|
GHC.Builtin.Uniques <= prelude/KnownUniques.hs
|
|
|
GHC.Builtin.Utils <= prelude/PrelInfo.hs
|
|
|
GHC.Builtin.Names <= prelude/PrelNames.hs
|
|
|
GHC.Builtin.Names.TH <= prelude/THNames.hs
|
|
|
GHC.Builtin.PrimOps <= prelude/PrimOp.hs
|
|
|
GHC.Builtin.Types <= prelude/TysWiredIn.hs
|
|
|
GHC.Builtin.Types.Literals <= typecheck/TcTypeNats.hs
|
|
|
GHC.Builtin.Types.Prim <= prelude/TysPrim.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.Iface`
|
|
|
|
|
|
```
|
|
|
GHC.Iface.Binary <= iface/BinIface.hs
|
|
|
GHC.Iface.Env <= iface/IfaceEnv.hs
|
|
|
GHC.Iface.Syntax <= iface/IfaceSyn.hs
|
|
|
GHC.Iface.Type <= iface/IfaceType.hs
|
|
|
GHC.Iface.Load <= iface/LoadIface.hs
|
|
|
GHC.Iface.Utils <= iface/MkIface.hs
|
|
|
GHC.Iface.Rename <= backpack/RnModIface.hs
|
|
|
GHC.Iface.Tidy <= main/TidyPgm.hs
|
|
|
GHC.Iface.Tidy.StaticPtrTable <= main/StaticPtrTable.hs
|
|
|
GHC.Iface.UpdateCafInfos <= main/UpdateCafInfos.hs
|
|
|
|
|
|
GHC.Iface.Ext.Ast <= hieFile/HieAst.hs
|
|
|
GHC.Iface.Ext.Binary <= hieFile/HieBin.hs
|
|
|
GHC.Iface.Ext.Debug <= hieFile/HieDebug.hs
|
|
|
GHC.Iface.Ext.Types <= hieFile/HieTypes.hs
|
|
|
GHC.Iface.Ext.Utils <= hieFile/HieUtils.hs
|
|
|
|
|
|
GHC.Iface.Recomp.Binary <= iface/BinFingerprint.hs
|
|
|
GHC.Iface.Recomp.Flags <= iface/FlagChecker.hs
|
|
|
|
|
|
GHC.IfaceToCore <= iface/TcIface.hs
|
|
|
GHC.CoreToIface <= iface/ToIface.hs
|
|
|
```
|
|
|
* `GHC.ByteCode`:
|
|
|
|
|
|
```
|
|
|
GHC.ByteCode.Asm <= ghci/ByteCodeAsm.hs
|
|
|
GHC.ByteCode.Instr <= ghci/ByteCodeInstr.hs
|
|
|
GHC.ByteCode.InfoTable <= ghci/ByteCodeItbls.hs
|
|
|
GHC.ByteCode.Linker <= ghci/ByteCodeLink.hs
|
|
|
GHC.ByteCode.Types <= ghci/ByteCodeTypes.hs
|
|
|
|
|
|
GHC.CoreToByteCode <= ghci/ByteCodeGen.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.Llvm`:
|
|
|
|
|
|
```
|
|
|
GHC.Llvm.MetaData <= llvmGen/Llvm/MetaData.hs
|
|
|
GHC.Llvm.Ppr <= llvmGen/Llvm/PpLlvm.hs
|
|
|
GHC.Llvm.Types <= llvmGen/Llvm/Types.hs
|
|
|
GHC.Llvm.Syntax <= llvmGen/Llvm/AbsSyn.hs
|
|
|
GHC.Llvm <= llvmGen/Llvm.hs
|
|
|
|
|
|
GHC.CmmToLlvm <= llvmGen/LlvmCodeGen.hs
|
|
|
GHC.CmmToLlvm.Mangler <= llvmGen/LlvmMangler.hs
|
|
|
GHC.CmmToLlvm.Base <= llvmGen/LlvmCodeGen/Base.hs
|
|
|
GHC.CmmToLlvm.CodeGen <= llvmGen/LlvmCodeGen/CodeGen.hs
|
|
|
GHC.CmmToLlvm.Data <= llvmGen/LlvmCodeGen/Data.hs
|
|
|
GHC.CmmToLlvm.Ppr <= llvmGen/LlvmCodeGen/Ppr.hs
|
|
|
GHC.CmmToLlvm.Regs <= llvmGen/LlvmCodeGen/Regs.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.Runtime`:
|
|
|
|
|
|
```
|
|
|
GHC.Runtime.Debugger <= ghci/Debugger.hs
|
|
|
GHC.Runtime.Interpreter <= ghci/GHCi.hs
|
|
|
GHC.Runtime.Linker <= ghci/Linker.hs
|
|
|
GHC.Runtime.Linker.Types <= ghci/LinkerTypes.hs
|
|
|
GHC.Runtime.Loader <= main/DynamicLoading.hs
|
|
|
GHC.Runtime.Eval <= main/InteractiveEval.hs
|
|
|
GHC.Runtime.Eval.Types <= main/InteractiveEvalTypes.hs
|
|
|
GHC.Runtime.Heap.Layout <= cmm/SMRep.hs
|
|
|
GHC.Runtime.Heap.Inspect <= ghci/RtClosureInspect.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.Driver`:
|
|
|
|
|
|
```
|
|
|
GHC.Driver.Backpack.Syntax <= backpack/BkpSyn.hs
|
|
|
GHC.Driver.Backpack <= backpack/DriverBkp.hs
|
|
|
GHC.Driver.CmdLine <= main/CmdLineParser.hs
|
|
|
GHC.Driver.CodeOutput <= main/CodeOutput.hs
|
|
|
GHC.Driver.Finder <= main/Finder.hs
|
|
|
GHC.Driver.MakeFile <= main/DriverMkDepend.hs
|
|
|
GHC.Driver.Main <= main/HscMain.hs
|
|
|
GHC.Driver.Make <= main/GhcMake.hs
|
|
|
GHC.Driver.Hooks <= main/Hooks.hs
|
|
|
GHC.Driver.Session <= main/DynFlags.hs
|
|
|
GHC.Driver.Packages <= main/Packages.hs
|
|
|
GHC.Driver.Phases <= main/DriverPhases.hs
|
|
|
GHC.Driver.Pipeline <= main/DriverPipeline.hs
|
|
|
GHC.Driver.Pipeline.Monad <= main/PipelineMonad.hs
|
|
|
GHC.Driver.Plugins <= main/Plugins.hs
|
|
|
GHC.Driver.Monad <= main/GhcMonad.hs
|
|
|
GHC.Driver.Types <= main/HscTypes.hs RAE: this 3,200-line file is imported by low-level things. I suppose it will have to be broken up.
|
|
|
|
|
|
GHC.Plugins <= main/GhcPlugins.hs -- module imported by plugins
|
|
|
GHC <= main/GHC.hs -- imported by GHC API users (could need some cleanup)
|
|
|
```
|
|
|
|
|
|
* `GHC.CmmToAsm`:
|
|
|
|
|
|
```
|
|
|
GHC.CmmToAsm <= nativeGen/AsmCodeGen.hs
|
|
|
GHC.CmmToAsm.BlockLayout <= nativeGen/BlockLayout.hs
|
|
|
GHC.CmmToAsm.CFG <= nativeGen/CFG.hs
|
|
|
GHC.CmmToAsm.CFG.Dominators <= utils/Dominators.hs
|
|
|
GHC.CmmToAsm.CPrim <= nativeGen/CPrim.hs
|
|
|
GHC.CmmToAsm.Dwarf.Constants <= nativeGen/Dwarf/Constants.hs
|
|
|
GHC.CmmToAsm.Dwarf <= nativeGen/Dwarf.hs
|
|
|
GHC.CmmToAsm.Dwarf.Types <= nativeGen/Dwarf/Types.hs
|
|
|
GHC.CmmToAsm.Format <= nativeGen/Format.hs
|
|
|
GHC.CmmToAsm.Instr <= nativeGen/Instruction.hs
|
|
|
GHC.CmmToAsm.Monad <= nativeGen/NCGMonad.hs
|
|
|
GHC.CmmToAsm.PIC <= nativeGen/PIC.hs
|
|
|
|
|
|
GHC.CmmToAsm.Ppr <= nativeGen/PprBase.hs
|
|
|
|
|
|
GHC.CmmToAsm.Reg.Graph.Base <= nativeGen/RegAlloc/Graph/ArchBase.hs
|
|
|
GHC.CmmToAsm.Reg.Graph.X86 <= nativeGen/RegAlloc/Graph/ArchX86.hs
|
|
|
GHC.CmmToAsm.Reg.Graph.Coalesce <= nativeGen/RegAlloc/Graph/Coalesce.hs
|
|
|
GHC.CmmToAsm.Reg.Graph <= nativeGen/RegAlloc/Graph/Main.hs
|
|
|
GHC.CmmToAsm.Reg.Graph.SpillClean <= nativeGen/RegAlloc/Graph/SpillClean.hs
|
|
|
GHC.CmmToAsm.Reg.Graph.SpillCost <= nativeGen/RegAlloc/Graph/SpillCost.hs
|
|
|
GHC.CmmToAsm.Reg.Graph.Spill <= nativeGen/RegAlloc/Graph/Spill.hs
|
|
|
GHC.CmmToAsm.Reg.Graph.Stats <= nativeGen/RegAlloc/Graph/Stats.hs
|
|
|
GHC.CmmToAsm.Reg.Graph.TrivColorable <= nativeGen/RegAlloc/Graph/TrivColorable.hs
|
|
|
|
|
|
GHC.CmmToAsm.Reg.Linear.Base <= nativeGen/RegAlloc/Linear/Base.hs
|
|
|
GHC.CmmToAsm.Reg.Linear.JoinToTargets <= nativeGen/RegAlloc/Linear/JoinToTargets.hs
|
|
|
GHC.CmmToAsm.Reg.Linear <= nativeGen/RegAlloc/Linear/Main.hs
|
|
|
GHC.CmmToAsm.Reg.Linear.StackMap <= nativeGen/RegAlloc/Linear/StackMap.hs
|
|
|
GHC.CmmToAsm.Reg.Linear.State <= nativeGen/RegAlloc/Linear/State.hs
|
|
|
GHC.CmmToAsm.Reg.Linear.Stats <= nativeGen/RegAlloc/Linear/Stats.hs
|
|
|
GHC.CmmToAsm.Reg.Linear.FreeRegs <= nativeGen/RegAlloc/Linear/FreeRegs.hs
|
|
|
GHC.CmmToAsm.Reg.Linear.PPC <= nativeGen/RegAlloc/Linear/PPC/FreeRegs.hs
|
|
|
GHC.CmmToAsm.Reg.Linear.SPARC <= nativeGen/RegAlloc/Linear/SPARC/FreeRegs.hs
|
|
|
GHC.CmmToAsm.Reg.Linear.X86_64 <= nativeGen/RegAlloc/Linear/X86_64/FreeRegs.hs
|
|
|
GHC.CmmToAsm.Reg.Linear.X86 <= nativeGen/RegAlloc/Linear/X86/FreeRegs.hs
|
|
|
|
|
|
GHC.Platform.Reg <= nativeGen/Reg.hs
|
|
|
GHC.Platform.Reg.Class <= nativeGen/RegClass.hs
|
|
|
|
|
|
GHC.CmmToAsm.Reg.Liveness <= nativeGen/RegAlloc/Liveness.hs
|
|
|
GHC.CmmToAsm.Reg.Target <= nativeGen/TargetReg.hs
|
|
|
|
|
|
GHC.CmmToAsm.PPC.CodeGen <= nativeGen/PPC/CodeGen.hs
|
|
|
GHC.CmmToAsm.PPC.Cond <= nativeGen/PPC/Cond.hs
|
|
|
GHC.CmmToAsm.PPC.Instr <= nativeGen/PPC/Instr.hs
|
|
|
GHC.CmmToAsm.PPC.Ppr <= nativeGen/PPC/Ppr.hs
|
|
|
GHC.CmmToAsm.PPC.RegInfo <= nativeGen/PPC/RegInfo.hs
|
|
|
GHC.CmmToAsm.PPC.Regs <= nativeGen/PPC/Regs.hs
|
|
|
|
|
|
GHC.CmmToAsm.SPARC.AddrMode <= nativeGen/SPARC/AddrMode.hs
|
|
|
GHC.CmmToAsm.SPARC.Base <= nativeGen/SPARC/Base.hs
|
|
|
GHC.CmmToAsm.SPARC.CodeGen.Amode <= nativeGen/SPARC/CodeGen/Amode.hs
|
|
|
GHC.CmmToAsm.SPARC.CodeGen.Base <= nativeGen/SPARC/CodeGen/Base.hs
|
|
|
GHC.CmmToAsm.SPARC.CodeGen.CondCode <= nativeGen/SPARC/CodeGen/CondCode.hs
|
|
|
GHC.CmmToAsm.SPARC.CodeGen.Expand <= nativeGen/SPARC/CodeGen/Expand.hs
|
|
|
GHC.CmmToAsm.SPARC.CodeGen.Gen32 <= nativeGen/SPARC/CodeGen/Gen32.hs
|
|
|
GHC.CmmToAsm.SPARC.CodeGen.Gen64 <= nativeGen/SPARC/CodeGen/Gen64.hs
|
|
|
GHC.CmmToAsm.SPARC.CodeGen <= nativeGen/SPARC/CodeGen.hs
|
|
|
GHC.CmmToAsm.SPARC.CodeGen.Sanity <= nativeGen/SPARC/CodeGen/Sanity.hs
|
|
|
GHC.CmmToAsm.SPARC.Cond <= nativeGen/SPARC/Cond.hs
|
|
|
GHC.CmmToAsm.SPARC.Imm <= nativeGen/SPARC/Imm.hs
|
|
|
GHC.CmmToAsm.SPARC.Instr <= nativeGen/SPARC/Instr.hs
|
|
|
GHC.CmmToAsm.SPARC.Ppr <= nativeGen/SPARC/Ppr.hs
|
|
|
GHC.CmmToAsm.SPARC.Regs <= nativeGen/SPARC/Regs.hs
|
|
|
GHC.CmmToAsm.SPARC.ShortcutJump <= nativeGen/SPARC/ShortcutJump.hs
|
|
|
GHC.CmmToAsm.SPARC.Stack <= nativeGen/SPARC/Stack.hs
|
|
|
|
|
|
GHC.CmmToAsm.X86.CodeGen <= nativeGen/X86/CodeGen.hs
|
|
|
GHC.CmmToAsm.X86.Cond <= nativeGen/X86/Cond.hs
|
|
|
GHC.CmmToAsm.X86.Instr <= nativeGen/X86/Instr.hs
|
|
|
GHC.CmmToAsm.X86.Ppr <= nativeGen/X86/Ppr.hs
|
|
|
GHC.CmmToAsm.X86.RegInfo <= nativeGen/X86/RegInfo.hs
|
|
|
GHC.CmmToAsm.X86.Regs <= nativeGen/X86/Regs.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.Data`:
|
|
|
|
|
|
```
|
|
|
GHC.Data.Bitmap <= cmm/Bitmap.hs
|
|
|
GHC.Data.Bag <= utils/Bag.hs
|
|
|
GHC.Data.BooleanFormula <= utils/BooleanFormula.hs
|
|
|
GHC.Data.EnumSet <= utils/EnumSet.hs
|
|
|
GHC.Data.FastMutInt <= utils/FastMutInt.hs
|
|
|
GHC.Data.FastString.Env <= utils/FastStringEnv.hs
|
|
|
GHC.Data.FastString <= utils/FastString.hs
|
|
|
GHC.Data.Graph.Base <= utils/GraphBase.hs
|
|
|
GHC.Data.Graph.Color <= utils/GraphColor.hs
|
|
|
GHC.Data.Graph.Directed <= utils/Digraph.hs
|
|
|
GHC.Data.Graph.Ops <= utils/GraphOps.hs
|
|
|
GHC.Data.Graph.Ppr <= utils/GraphPpr.hs
|
|
|
GHC.Data.Graph.UnVar <= utils/UnVarGraph.hs
|
|
|
GHC.Data.IOEnv <= utils/IOEnv.hs
|
|
|
GHC.Data.List.SetOps <= utils/ListSetOps.hs
|
|
|
GHC.Data.Maybe <= utils/Maybes.hs
|
|
|
GHC.Data.FiniteMap <= utils/FiniteMap.hs
|
|
|
GHC.Data.OrdList <= utils/OrdList.hs
|
|
|
GHC.Data.Pair <= utils/Pair.hs
|
|
|
GHC.Data.Stream <= utils/Stream.hs
|
|
|
GHC.Data.StringBuffer <= utils/StringBuffer.hs
|
|
|
GHC.Data.TrieMap <= utils/TrieMap.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.Utils`:
|
|
|
|
|
|
```
|
|
|
GHC.Utils.Asm <= utils/AsmUtils.hs
|
|
|
GHC.Utils.Binary <= utils/Binary.hs
|
|
|
GHC.Utils.BufHandle <= utils/BufWrite.hs
|
|
|
GHC.Utils.Encoding <= utils/Encoding.hs
|
|
|
GHC.Utils.Exception <= utils/Exception.hs
|
|
|
GHC.Utils.FingerPrint <= utils/Fingerprint.hs
|
|
|
GHC.Utils.Json <= utils/Json.hs
|
|
|
GHC.Utils.Outputable <= utils/Outputable.hs
|
|
|
GHC.Utils.Panic <= utils/Panic.hs
|
|
|
GHC.Utils.Panic.Plain <= utils/PlainPanic.hs
|
|
|
GHC.Utils.Ppr.Colour <= utils/PprColour.hs
|
|
|
GHC.Utils.Ppr <= utils/Pretty.hs
|
|
|
GHC.Utils.Misc <= utils/Util.hs
|
|
|
GHC.Utils.Error <= main/ErrUtils.hs
|
|
|
GHC.Utils.CliOption <= main/CliOption.hs
|
|
|
GHC.Utils.FV <= utils/FV.hs
|
|
|
|
|
|
GHC.Utils.IO.Unsafe <= utils/FastFunctions.hs
|
|
|
|
|
|
GHC.Utils.Monad.Utils <= utils/MonadUtils.hs
|
|
|
GHC.Utils.Monad.State <= utils/State.hs
|
|
|
|
|
|
GHC.Prelude <= utils/GhcPrelude.hs
|
|
|
|
|
|
GHC.Unit.Info <= main/UnitInfo.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.SysTools`:
|
|
|
|
|
|
```
|
|
|
GHC.SysTools.BaseDir <= main/SysTools/BaseDir.hs
|
|
|
GHC.SysTools.ExtraObj <= main/SysTools/ExtraObj.hs
|
|
|
GHC.SysTools <= main/SysTools.hs
|
|
|
GHC.SysTools.Info <= main/SysTools/Info.hs
|
|
|
GHC.SysTools.Process <= main/SysTools/Process.hs
|
|
|
GHC.SysTools.Tasks <= main/SysTools/Tasks.hs
|
|
|
GHC.SysTools.Terminal <= main/SysTools/Terminal.hs
|
|
|
GHC.SysTools.Ar <= main/Ar.hs
|
|
|
GHC.SysTools.Elf <= main/Elf.hs
|
|
|
GHC.SysTools.FileCleanup <= main/FileCleanup.hs
|
|
|
```
|
|
|
|
|
|
* `GHC.Parser`:
|
|
|
|
|
|
```
|
|
|
GHC.Parser <= parse/Parser.y
|
|
|
GHC.Parser.Annotation <= parser/ApiAnnotation.hs
|
|
|
GHC.Parser.CharClass <= parser/Ctype.hs
|
|
|
GHC.Parser.Lexer <= parse/Lexer.x
|
|
|
GHC.Parser.Header <= main/HeaderInfo.hs
|
|
|
GHC.Parser.PostProcess <= parser/RdrHsSyn.hs
|
|
|
GHC.Parser.PostProcess.Haddock <= parser/HaddockUtils
|
|
|
```
|
|
|
|
|
|
* `GHC.Settings`:
|
|
|
|
|
|
```
|
|
|
GHC.Settings <= main/Settings.hs, main/FileSettings.hs, main/ToolSettings.hs, main/GhcNameVersion.hs, main/PlatformConstants.hs
|
|
|
GHC.Settings.Constants <= main/Constants.hs
|
|
|
GHC.Settings.IO <= main/SysTools/Settings.hs
|
|
|
|
|
|
in ghc-boot:
|
|
|
GHC.Settings.{Platform,Utils} <= GHC.Settings
|
|
|
```
|
|
|
|
|
|
|
|
|
Reduce the dependencies on DynFlags
|
|
|
-----------------------------------
|
|
|
|
|
|
DynFlags is a huge (mutable) datatype that is passed to many functions in the compiler. We can make the transition smoother by defining the following kind of classes and instances:
|
|
|
|
|
|
```
|
|
|
-- in GHC.StgToCmm.Options
|
|
|
class HasOptions a where
|
|
|
stgToCmmXXX :: Bool
|
|
|
...
|
|
|
|
|
|
data Options = Options
|
|
|
{ _stgToCmmXXX :: Bool
|
|
|
, ...
|
|
|
}
|
|
|
|
|
|
stgToCmm :: HasOptions a => a -> Stg -> Cmm
|
|
|
|
|
|
-- in GHC.Driver.Options
|
|
|
instance StgToCmm.HasOptions DynFlags where
|
|
|
...
|
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
Make the compiler as pure as possible
|
|
|
-------------------------------------
|
|
|
- [ ] Make the compiler as pure as possible (#17957)
|
|
|
|
|
|
* Reduce the dependencies on DynFlags (#17957)
|
|
|
* IR-to-IR should callback into the driving code to perform IO (e.g. when they need an interface to be loaded). They can return a continuation to resume their work.
|
|
|
* Don't assume that a filesystem is present
|
|
|
* Abstract file loading (i.e. make the Finder configurable, like Java's class loaders).
|
... | ... | |