Module hierarchy (#13009): Stg

44 files changed, 224 insertions, 226 deletions

diff --git a/compiler/stgSyn/CoreToStg.hs b/compiler/GHC/CoreToStg.hs
index 4982ad68f4..1ee5febd2e 100644
--- a/compiler/stgSyn/CoreToStg.hs
+++ b/compiler/GHC/CoreToStg.hs
@@ -11,7 +11,7 @@
 -- And, as we have the info in hand, we may convert some lets to
 -- let-no-escapes.
 
-module CoreToStg ( coreToStg ) where
+module GHC.CoreToStg ( coreToStg ) where
 
 #include "HsVersions.h"
 
@@ -21,10 +21,10 @@ import CoreSyn
 import CoreUtils        ( exprType, findDefault, isJoinBind
                         , exprIsTickedString_maybe )
 import CoreArity        ( manifestArity )
-import StgSyn
+import GHC.Stg.Syntax
 
 import Type
-import RepType
+import GHC.Types.RepType
 import TyCon
 import MkId             ( coercionTokenId )
 import Id
diff --git a/compiler/coreSyn/CorePrep.hs b/compiler/GHC/CoreToStg/Prep.hs
index 227ad8542c..ea020c5f9e 100644
--- a/compiler/coreSyn/CorePrep.hs
+++ b/compiler/GHC/CoreToStg/Prep.hs
@@ -7,7 +7,7 @@ Core pass to saturate constructors and PrimOps
 
 {-# LANGUAGE BangPatterns, CPP, MultiWayIf #-}
 
-module CorePrep (
+module GHC.CoreToStg.Prep (
       corePrepPgm, corePrepExpr, cvtLitInteger, cvtLitNatural,
       lookupMkIntegerName, lookupIntegerSDataConName,
       lookupMkNaturalName, lookupNaturalSDataConName
diff --git a/compiler/simplStg/StgCse.hs b/compiler/GHC/Stg/CSE.hs
index 269738e488..66f5004b49 100644
--- a/compiler/simplStg/StgCse.hs
+++ b/compiler/GHC/Stg/CSE.hs
@@ -84,13 +84,13 @@ Solution: do unarise first.
 
 -}
 
-module StgCse (stgCse) where
+module GHC.Stg.CSE (stgCse) where
 
 import GhcPrelude
 
 import DataCon
 import Id
-import StgSyn
+import GHC.Stg.Syntax
 import Outputable
 import VarEnv
 import CoreSyn (AltCon(..))
diff --git a/compiler/stgSyn/StgFVs.hs b/compiler/GHC/Stg/FVs.hs
index ad02642aa9..65f80d97af 100644
--- a/compiler/stgSyn/StgFVs.hs
+++ b/compiler/GHC/Stg/FVs.hs
@@ -1,12 +1,12 @@
 -- | Free variable analysis on STG terms.
-module StgFVs (
+module GHC.Stg.FVs (
     annTopBindingsFreeVars,
     annBindingFreeVars
   ) where
 
 import GhcPrelude
 
-import StgSyn
+import GHC.Stg.Syntax
 import Id
 import VarSet
 import CoreSyn    ( Tickish(Breakpoint) )
diff --git a/compiler/simplStg/StgLiftLams/Transformation.hs b/compiler/GHC/Stg/Lift.hs
index bef39a1856..cafcafbd42 100644
--- a/compiler/simplStg/StgLiftLams/Transformation.hs
+++ b/compiler/GHC/Stg/Lift.hs
@@ -1,8 +1,19 @@
 {-# LANGUAGE CPP #-}
 
--- | (Mostly) textbook instance of the lambda lifting transformation,
--- selecting which bindings to lambda lift by consulting 'goodToLift'.
-module StgLiftLams.Transformation (stgLiftLams) where
+-- | Implements a selective lambda lifter, running late in the optimisation
+-- pipeline.
+--
+-- If you are interested in the cost model that is employed to decide whether
+-- to lift a binding or not, look at "GHC.Stg.Lift.Analysis".
+-- "GHC.Stg.Lift.Monad" contains the transformation monad that hides away some
+-- plumbing of the transformation.
+module GHC.Stg.Lift
+   (
+    -- * Late lambda lifting in STG
+    -- $note
+   stgLiftLams
+   )
+where
 
 #include "HsVersions.h"
 
@@ -12,10 +23,10 @@ import BasicTypes
 import DynFlags
 import Id
 import IdInfo
-import StgFVs ( annBindingFreeVars )
-import StgLiftLams.Analysis
-import StgLiftLams.LiftM
-import StgSyn
+import GHC.Stg.FVs ( annBindingFreeVars )
+import GHC.Stg.Lift.Analysis
+import GHC.Stg.Lift.Monad
+import GHC.Stg.Syntax
 import Outputable
 import UniqSupply
 import Util
@@ -23,7 +34,99 @@ import VarSet
 import Control.Monad ( when )
 import Data.Maybe ( isNothing )
 
+-- Note [Late lambda lifting in STG]
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-- $note
+-- See also the <https://gitlab.haskell.org/ghc/ghc/wikis/late-lam-lift wiki page>
+-- and #9476.
+--
+-- The basic idea behind lambda lifting is to turn locally defined functions
+-- into top-level functions. Free variables are then passed as additional
+-- arguments at *call sites* instead of having a closure allocated for them at
+-- *definition site*. Example:
+--
+-- @
+--    let x = ...; y = ... in
+--    let f = {x y} \a -> a + x + y in
+--    let g = {f x} \b -> f b + x in
+--    g 5
+-- @
+--
+-- Lambda lifting @f@ would
+--
+--   1. Turn @f@'s free variables into formal parameters
+--   2. Update @f@'s call site within @g@ to @f x y b@
+--   3. Update @g@'s closure: Add @y@ as an additional free variable, while
+--      removing @f@, because @f@ no longer allocates and can be floated to
+--      top-level.
+--   4. Actually float the binding of @f@ to top-level, eliminating the @let@
+--      in the process.
+--
+-- This results in the following program (with free var annotations):
+--
+-- @
+--    f x y a = a + x + y;
+--    let x = ...; y = ... in
+--    let g = {x y} \b -> f x y b + x in
+--    g 5
+-- @
+--
+-- This optimisation is all about lifting only when it is beneficial to do so.
+-- The above seems like a worthwhile lift, judging from heap allocation:
+-- We eliminate @f@'s closure, saving to allocate a closure with 2 words, while
+-- not changing the size of @g@'s closure.
+--
+-- You can probably sense that there's some kind of cost model at play here.
+-- And you are right! But we also employ a couple of other heuristics for the
+-- lifting decision which are outlined in "GHC.Stg.Lift.Analysis#when".
+--
+-- The transformation is done in "GHC.Stg.Lift", which calls out to
+-- 'GHC.Stg.Lift.Analysis.goodToLift' for its lifting decision.  It relies on
+-- "GHC.Stg.Lift.Monad", which abstracts some subtle STG invariants into a
+-- monadic substrate.
+--
+-- Suffice to say: We trade heap allocation for stack allocation.
+-- The additional arguments have to passed on the stack (or in registers,
+-- depending on architecture) every time we call the function to save a single
+-- heap allocation when entering the let binding. Nofib suggests a mean
+-- improvement of about 1% for this pass, so it seems like a worthwhile thing to
+-- do. Compile-times went up by 0.6%, so all in all a very modest change.
+--
+-- For a concrete example, look at @spectral/atom@. There's a call to 'zipWith'
+-- that is ultimately compiled to something like this
+-- (module desugaring/lowering to actual STG):
+--
+-- @
+--    propagate dt = ...;
+--    runExperiment ... =
+--      let xs = ... in
+--      let ys = ... in
+--      let go = {dt go} \xs ys -> case (xs, ys) of
+--            ([], []) -> []
+--            (x:xs', y:ys') -> propagate dt x y : go xs' ys'
+--      in go xs ys
+-- @
+--
+-- This will lambda lift @go@ to top-level, speeding up the resulting program
+-- by roughly one percent:
+--
+-- @
+--    propagate dt = ...;
+--    go dt xs ys = case (xs, ys) of
+--      ([], []) -> []
+--      (x:xs', y:ys') -> propagate dt x y : go dt xs' ys'
+--    runExperiment ... =
+--      let xs = ... in
+--      let ys = ... in
+--      in go dt xs ys
+-- @
+
+
+
 -- | Lambda lifts bindings to top-level deemed worth lifting (see 'goodToLift').
+--
+-- (Mostly) textbook instance of the lambda lifting transformation, selecting
+-- which bindings to lambda lift by consulting 'goodToLift'.
 stgLiftLams :: DynFlags -> UniqSupply -> [InStgTopBinding] -> [OutStgTopBinding]
 stgLiftLams dflags us = runLiftM dflags us . foldr liftTopLvl (pure ())
 
diff --git a/compiler/simplStg/StgLiftLams/Analysis.hs b/compiler/GHC/Stg/Lift/Analysis.hs
index 8bcd6f6cb5..02d439cef7 100644
--- a/compiler/simplStg/StgLiftLams/Analysis.hs
+++ b/compiler/GHC/Stg/Lift/Analysis.hs
@@ -5,7 +5,7 @@
 -- | Provides the heuristics for when it's beneficial to lambda lift bindings.
 -- Most significantly, this employs a cost model to estimate impact on heap
 -- allocations, by looking at an STG expression's 'Skeleton'.
-module StgLiftLams.Analysis (
+module GHC.Stg.Lift.Analysis (
     -- * #when# When to lift
     -- $when
 
@@ -27,7 +27,7 @@ import Demand
 import DynFlags
 import Id
 import SMRep ( WordOff )
-import StgSyn
+import GHC.Stg.Syntax
 import qualified GHC.StgToCmm.ArgRep  as StgToCmm.ArgRep
 import qualified GHC.StgToCmm.Closure as StgToCmm.Closure
 import qualified GHC.StgToCmm.Layout  as StgToCmm.Layout
@@ -45,7 +45,7 @@ import Data.Maybe ( mapMaybe )
 --   1. It tags the syntax tree with analysis information in the form of
 --      'BinderInfo' at each binder and 'Skeleton's at each let-binding
 --      by 'tagSkeletonTopBind' and friends.
---   2. The resulting syntax tree is treated by the "StgLiftLams.Transformation"
+--   2. The resulting syntax tree is treated by the "GHC.Stg.Lift"
 --      module, calling out to 'goodToLift' to decide if a binding is worthwhile
 --      to lift.
 --      'goodToLift' consults argument occurrence information in 'BinderInfo'
@@ -78,7 +78,7 @@ import Data.Maybe ( mapMaybe )
 --  [Closure growth] introduced when former free variables have to be available
 --    at call sites may actually lead to an increase in overall allocations
 --  resulting from a lift. Estimating closure growth is described in
---  "StgLiftLams.Analysis#clogro" and is what most of this module is ultimately
+--  "GHC.Stg.Lift.Analysis#clogro" and is what most of this module is ultimately
 --  concerned with.
 --
 -- There's a <https://gitlab.haskell.org/ghc/ghc/wikis/late-lam-lift wiki page> with
@@ -145,7 +145,7 @@ data BinderInfo
   = BindsClosure !Id !Bool -- ^ Let(-no-escape)-bound thing with a flag
                            --   indicating whether it occurs as an argument
                            --   or in a nullary application
-                           --   (see "StgLiftLams.Analysis#arg_occs").
+                           --   (see "GHC.Stg.Lift.Analysis#arg_occs").
   | BoringBinder !Id       -- ^ Every other kind of binder
 
 -- | Gets the bound 'Id' out a 'BinderInfo'.
@@ -214,7 +214,7 @@ tagSkeletonTopBind bind = bind'
 -- | Tags binders of an 'StgExpr' with its 'BinderInfo' and let bindings with
 -- their 'Skeleton's. Additionally, returns its 'Skeleton' and the set of binder
 -- occurrences in argument and nullary application position
--- (cf. "StgLiftLams.Analysis#arg_occs").
+-- (cf. "GHC.Stg.Lift.Analysis#arg_occs").
 tagSkeletonExpr :: CgStgExpr -> (Skeleton, IdSet, LlStgExpr)
 tagSkeletonExpr (StgLit lit)
   = (NilSk, emptyVarSet, StgLit lit)
@@ -227,7 +227,7 @@ tagSkeletonExpr (StgApp f args)
   where
     arg_occs
       -- This checks for nullary applications, which we treat the same as
-      -- argument occurrences, see "StgLiftLams.Analysis#arg_occs".
+      -- argument occurrences, see "GHC.Stg.Lift.Analysis#arg_occs".
       | null args = unitVarSet f
       | otherwise = mkArgOccs args
 tagSkeletonExpr (StgLam _ _) = pprPanic "stgLiftLams" (text "StgLam")
@@ -352,13 +352,13 @@ tagSkeletonAlt (con, bndrs, rhs)
     arg_occs = alt_arg_occs `delVarSetList` bndrs
 
 -- | Combines several heuristics to decide whether to lambda-lift a given
--- @let@-binding to top-level. See "StgLiftLams.Analysis#when" for details.
+-- @let@-binding to top-level. See "GHC.Stg.Lift.Analysis#when" for details.
 goodToLift
   :: DynFlags
   -> TopLevelFlag
   -> RecFlag
   -> (DIdSet -> DIdSet) -- ^ An expander function, turning 'InId's into
-                        -- 'OutId's. See 'StgLiftLams.LiftM.liftedIdsExpander'.
+                        -- 'OutId's. See 'GHC.Stg.Lift.Monad.liftedIdsExpander'.
   -> [(BinderInfo, LlStgRhs)]
   -> Skeleton
   -> Maybe DIdSet       -- ^ @Just abs_ids@ <=> This binding is beneficial to
@@ -507,7 +507,7 @@ idClosureFootprint dflags
 -- | @closureGrowth expander sizer f fvs@ computes the closure growth in words
 -- as a result of lifting @f@ to top-level. If there was any growing closure
 -- under a multi-shot lambda, the result will be 'infinity'.
--- Also see "StgLiftLams.Analysis#clogro".
+-- Also see "GHC.Stg.Lift.Analysis#clogro".
 closureGrowth
   :: (DIdSet -> DIdSet)
   -- ^ Expands outer free ids that were lifted to their free vars
diff --git a/compiler/simplStg/StgLiftLams/LiftM.hs b/compiler/GHC/Stg/Lift/Monad.hs
index 710eb1f289..7d17e53cd9 100644
--- a/compiler/simplStg/StgLiftLams/LiftM.hs
+++ b/compiler/GHC/Stg/Lift/Monad.hs
@@ -4,7 +4,7 @@
 
 -- | Hides away distracting bookkeeping while lambda lifting into a 'LiftM'
 -- monad.
-module StgLiftLams.LiftM (
+module GHC.Stg.Lift.Monad (
     decomposeStgBinding, mkStgBinding,
     Env (..),
     -- * #floats# Handling floats
@@ -33,8 +33,8 @@ import IdInfo
 import Name
 import Outputable
 import OrdList
-import StgSubst
-import StgSyn
+import GHC.Stg.Subst
+import GHC.Stg.Syntax
 import Type
 import UniqSupply
 import Util
@@ -137,7 +137,7 @@ emptyEnv dflags = Env dflags emptySubst emptyVarEnv False
 -- business and will just manipulate it indirectly through actions in 'LiftM'.
 
 -- | We need to detect when we are lifting something out of the RHS of a
--- recursive binding (c.f. "StgLiftLams.LiftM#floats"), in which case that
+-- recursive binding (c.f. "GHC.Stg.Lift.Monad#floats"), in which case that
 -- binding needs to be added to the same top-level recursive group. This
 -- requires we detect a certain nesting structure, which is encoded by
 -- 'StartBindingGroup' and 'EndBindingGroup'.
diff --git a/compiler/stgSyn/StgLint.hs b/compiler/GHC/Stg/Lint.hs
index f83b44859c..e7044a89e0 100644
--- a/compiler/stgSyn/StgLint.hs
+++ b/compiler/GHC/Stg/Lint.hs
@@ -35,11 +35,11 @@ basic properties listed above.
 {-# LANGUAGE ScopedTypeVariables, FlexibleContexts, TypeFamilies,
   DeriveFunctor #-}
 
-module StgLint ( lintStgTopBindings ) where
+module GHC.Stg.Lint ( lintStgTopBindings ) where
 
 import GhcPrelude
 
-import StgSyn
+import GHC.Stg.Syntax
 
 import DynFlags
 import Bag              ( Bag, emptyBag, isEmptyBag, snocBag, bagToList )
@@ -52,7 +52,7 @@ import CoreSyn          ( AltCon(..) )
 import Name             ( getSrcLoc, nameIsLocalOrFrom )
 import ErrUtils         ( MsgDoc, Severity(..), mkLocMessage )
 import Type
-import RepType
+import GHC.Types.RepType
 import SrcLoc
 import Outputable
 import Module           ( Module )
diff --git a/compiler/simplStg/SimplStg.hs b/compiler/GHC/Stg/Pipeline.hs
index 2b6eeded42..13b403fc53 100644
--- a/compiler/simplStg/SimplStg.hs
+++ b/compiler/GHC/Stg/Pipeline.hs
@@ -9,19 +9,19 @@
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE TypeFamilies #-}
 
-module SimplStg ( stg2stg ) where
+module GHC.Stg.Pipeline ( stg2stg ) where
 
 #include "HsVersions.h"
 
 import GhcPrelude
 
-import StgSyn
+import GHC.Stg.Syntax
 
-import StgLint          ( lintStgTopBindings )
-import StgStats         ( showStgStats )
-import UnariseStg       ( unarise )
-import StgCse           ( stgCse )
-import StgLiftLams      ( stgLiftLams )
+import GHC.Stg.Lint     ( lintStgTopBindings )
+import GHC.Stg.Stats    ( showStgStats )
+import GHC.Stg.Unarise  ( unarise )
+import GHC.Stg.CSE      ( stgCse )
+import GHC.Stg.Lift     ( stgLiftLams )
 import Module           ( Module )
 
 import DynFlags
@@ -128,7 +128,7 @@ getStgToDo dflags =
   filter (/= StgDoNothing)
     [ mandatory StgUnarise
     -- Important that unarisation comes first
-    -- See Note [StgCse after unarisation] in StgCse
+    -- See Note [StgCse after unarisation] in GHC.Stg.CSE
     , optional Opt_StgCSE StgCSE
     , optional Opt_StgLiftLams StgLiftLams
     , optional Opt_StgStats StgStats
diff --git a/compiler/simplStg/StgStats.hs b/compiler/GHC/Stg/Stats.hs
index 05a0cf988a..c70184e60b 100644
--- a/compiler/simplStg/StgStats.hs
+++ b/compiler/GHC/Stg/Stats.hs
@@ -23,13 +23,13 @@ The program gather statistics about
 
 {-# LANGUAGE CPP #-}
 
-module StgStats ( showStgStats ) where
+module GHC.Stg.Stats ( showStgStats ) where
 
 #include "HsVersions.h"
 
 import GhcPrelude
 
-import StgSyn
+import GHC.Stg.Syntax
 
 import Id (Id)
 import Panic
diff --git a/compiler/stgSyn/StgSubst.hs b/compiler/GHC/Stg/Subst.hs
index 0616c6c529..84b9f29c3c 100644
--- a/compiler/stgSyn/StgSubst.hs
+++ b/compiler/GHC/Stg/Subst.hs
@@ -1,6 +1,6 @@
 {-# LANGUAGE CPP #-}
 
-module StgSubst where
+module GHC.Stg.Subst where
 
 #include "HsVersions.h"
 
diff --git a/compiler/stgSyn/StgSyn.hs b/compiler/GHC/Stg/Syntax.hs
index 052ef2b6c7..b82fea5de2 100644
--- a/compiler/stgSyn/StgSyn.hs
+++ b/compiler/GHC/Stg/Syntax.hs
@@ -19,7 +19,7 @@ generation.
 {-# LANGUAGE UndecidableInstances #-}
 {-# LANGUAGE ConstraintKinds #-}
 
-module StgSyn (
+module GHC.Stg.Syntax (
         StgArg(..),
 
         GenStgTopBinding(..), GenStgBinding(..), GenStgExpr(..), GenStgRhs(..),
@@ -81,7 +81,7 @@ import PprCore     ( {- instances -} )
 import PrimOp      ( PrimOp, PrimCall )
 import TyCon       ( PrimRep(..), TyCon )
 import Type        ( Type )
-import RepType     ( typePrimRep1 )
+import GHC.Types.RepType     ( typePrimRep1 )
 import Util
 
 import Data.List.NonEmpty ( NonEmpty, toList )
@@ -238,7 +238,7 @@ literals.
         -- which can't be let-bound
   | StgConApp   DataCon
                 [StgArg] -- Saturated
-                [Type]   -- See Note [Types in StgConApp] in UnariseStg
+                [Type]   -- See Note [Types in StgConApp] in GHC.Stg.Unarise
 
   | StgOpApp    StgOp    -- Primitive op or foreign call
                 [StgArg] -- Saturated.
diff --git a/compiler/simplStg/UnariseStg.hs b/compiler/GHC/Stg/Unarise.hs
index 0bfc15645c..bc2ce4cb87 100644
--- a/compiler/simplStg/UnariseStg.hs
+++ b/compiler/GHC/Stg/Unarise.hs
@@ -194,7 +194,7 @@ STG programs after unarisation have these invariants:
 
 {-# LANGUAGE CPP, TupleSections #-}
 
-module UnariseStg (unarise) where
+module GHC.Stg.Unarise (unarise) where
 
 #include "HsVersions.h"
 
@@ -210,8 +210,8 @@ import MkCore (aBSENT_SUM_FIELD_ERROR_ID)
 import MkId (voidPrimId, voidArgId)
 import MonadUtils (mapAccumLM)
 import Outputable
-import RepType
-import StgSyn
+import GHC.Types.RepType
+import GHC.Stg.Syntax
 import Type
 import TysPrim (intPrimTy,wordPrimTy,word64PrimTy)
 import TysWiredIn
@@ -353,7 +353,7 @@ unariseExpr rho (StgCase scrut bndr alt_ty alts)
        alts'  <- unariseAlts rho alt_ty bndr alts
        return (StgCase scrut' bndr alt_ty alts')
                        -- bndr may have a unboxed sum/tuple type but it will be
-                       -- dead after unarise (checked in StgLint)
+                       -- dead after unarise (checked in GHC.Stg.Lint)
 
 unariseExpr rho (StgLet ext bind e)
   = StgLet ext <$> unariseBinding rho bind <*> unariseExpr rho e
diff --git a/compiler/GHC/StgToCmm.hs b/compiler/GHC/StgToCmm.hs
index f02d361fa4..10a9dc2c6a 100644
--- a/compiler/GHC/StgToCmm.hs
+++ b/compiler/GHC/StgToCmm.hs
@@ -30,7 +30,7 @@ import Cmm
 import CmmUtils
 import CLabel
 
-import StgSyn
+import GHC.Stg.Syntax
 import DynFlags
 import ErrUtils
 
@@ -38,7 +38,7 @@ import HscTypes
 import CostCentre
 import Id
 import IdInfo
-import RepType
+import GHC.Types.RepType
 import DataCon
 import TyCon
 import Module
@@ -147,7 +147,7 @@ cgTopRhs :: DynFlags -> RecFlag -> Id -> CgStgRhs -> (CgIdInfo, FCode ())
 cgTopRhs dflags _rec bndr (StgRhsCon _cc con args)
   = cgTopRhsCon dflags bndr con (assertNonVoidStgArgs args)
       -- con args are always non-void,
-      -- see Note [Post-unarisation invariants] in UnariseStg
+      -- see Note [Post-unarisation invariants] in GHC.Stg.Unarise
 
 cgTopRhs dflags rec bndr (StgRhsClosure fvs cc upd_flag args body)
   = ASSERT(isEmptyDVarSet fvs)    -- There should be no free variables
diff --git a/compiler/GHC/StgToCmm/Bind.hs b/compiler/GHC/StgToCmm/Bind.hs
index d373b79d0c..3eeb575da7 100644
--- a/compiler/GHC/StgToCmm/Bind.hs
+++ b/compiler/GHC/StgToCmm/Bind.hs
@@ -36,7 +36,7 @@ import Cmm
 import CmmInfo
 import CmmUtils
 import CLabel
-import StgSyn
+import GHC.Stg.Syntax
 import CostCentre
 import Id
 import IdInfo
@@ -206,7 +206,7 @@ cgRhs id (StgRhsCon cc con args)
   = withNewTickyCounterCon (idName id) $
     buildDynCon id True cc con (assertNonVoidStgArgs args)
       -- con args are always non-void,
-      -- see Note [Post-unarisation invariants] in UnariseStg
+      -- see Note [Post-unarisation invariants] in GHC.Stg.Unarise
 
 {- See Note [GC recovery] in compiler/GHC.StgToCmm/Closure.hs -}
 cgRhs id (StgRhsClosure fvs cc upd_flag args body)
@@ -275,7 +275,7 @@ mkRhsClosure    dflags bndr _cc
 
   , let (_, _, params_w_offsets) = mkVirtConstrOffsets dflags (addIdReps (assertNonVoidIds params))
                                    -- pattern binders are always non-void,
-                                   -- see Note [Post-unarisation invariants] in UnariseStg
+                                   -- see Note [Post-unarisation invariants] in GHC.Stg.Unarise
   , Just the_offset <- assocMaybe params_w_offsets (NonVoid selectee)
 
   , let offset_into_int = bytesToWordsRoundUp dflags the_offset
diff --git a/compiler/GHC/StgToCmm/Bind.hs-boot b/compiler/GHC/StgToCmm/Bind.hs-boot
index d16c34ebd3..6e8b2bdf7a 100644
--- a/compiler/GHC/StgToCmm/Bind.hs-boot
+++ b/compiler/GHC/StgToCmm/Bind.hs-boot
@@ -1,6 +1,6 @@
 module GHC.StgToCmm.Bind where
 
 import GHC.StgToCmm.Monad( FCode )
-import StgSyn( CgStgBinding )
+import GHC.Stg.Syntax( CgStgBinding )
 
 cgBind :: CgStgBinding -> FCode ()
diff --git a/compiler/GHC/StgToCmm/Closure.hs b/compiler/GHC/StgToCmm/Closure.hs
index 07d3edab9a..df8cb046c4 100644
--- a/compiler/GHC/StgToCmm/Closure.hs
+++ b/compiler/GHC/StgToCmm/Closure.hs
@@ -66,7 +66,7 @@ module GHC.StgToCmm.Closure (
 
 import GhcPrelude
 
-import StgSyn
+import GHC.Stg.Syntax
 import SMRep
 import Cmm
 import PprCmmExpr() -- For Outputable instances
@@ -82,7 +82,7 @@ import Type
 import TyCoRep
 import TcType
 import TyCon
-import RepType
+import GHC.Types.RepType
 import BasicTypes
 import Outputable
 import DynFlags
@@ -142,7 +142,7 @@ nonVoidIds ids = [NonVoid id | id <- ids, not (isVoidTy (idType id))]
 
 -- | Used in places where some invariant ensures that all these Ids are
 -- non-void; e.g. constructor field binders in case expressions.
--- See Note [Post-unarisation invariants] in UnariseStg.
+-- See Note [Post-unarisation invariants] in GHC.Stg.Unarise.
 assertNonVoidIds :: [Id] -> [NonVoid Id]
 assertNonVoidIds ids = ASSERT(not (any (isVoidTy . idType) ids))
                        coerce ids
@@ -152,7 +152,7 @@ nonVoidStgArgs args = [NonVoid arg | arg <- args, not (isVoidTy (stgArgType arg)
 
 -- | Used in places where some invariant ensures that all these arguments are
 -- non-void; e.g. constructor arguments.
--- See Note [Post-unarisation invariants] in UnariseStg.
+-- See Note [Post-unarisation invariants] in GHC.Stg.Unarise.
 assertNonVoidStgArgs :: [StgArg] -> [NonVoid StgArg]
 assertNonVoidStgArgs args = ASSERT(not (any (isVoidTy . stgArgType) args))
                             coerce args
@@ -169,7 +169,7 @@ assertNonVoidStgArgs args = ASSERT(not (any (isVoidTy . stgArgType) args))
 -- See Note [Post-unarisation invariants]
 idPrimRep :: Id -> PrimRep
 idPrimRep id = typePrimRep1 (idType id)
-    -- See also Note [VoidRep] in RepType
+    -- See also Note [VoidRep] in GHC.Types.RepType
 
 -- | Assumes that Ids have one PrimRep, which holds after unarisation.
 -- See Note [Post-unarisation invariants]
diff --git a/compiler/GHC/StgToCmm/DataCon.hs b/compiler/GHC/StgToCmm/DataCon.hs
index c7ad444e41..1e929663df 100644
--- a/compiler/GHC/StgToCmm/DataCon.hs
+++ b/compiler/GHC/StgToCmm/DataCon.hs
@@ -19,7 +19,7 @@ module GHC.StgToCmm.DataCon (
 
 import GhcPrelude
 
-import StgSyn
+import GHC.Stg.Syntax
 import CoreSyn  ( AltCon(..) )
 
 import GHC.StgToCmm.Monad
@@ -40,7 +40,7 @@ import DataCon
 import DynFlags
 import FastString
 import Id
-import RepType (countConRepArgs)
+import GHC.Types.RepType (countConRepArgs)
 import Literal
 import PrelInfo
 import Outputable
diff --git a/compiler/GHC/StgToCmm/Env.hs b/compiler/GHC/StgToCmm/Env.hs
index e32c6a1ecb..45b09a3d26 100644
--- a/compiler/GHC/StgToCmm/Env.hs
+++ b/compiler/GHC/StgToCmm/Env.hs
@@ -41,7 +41,7 @@ import Id
 import MkGraph
 import Name
 import Outputable
-import StgSyn
+import GHC.Stg.Syntax
 import Type
 import TysPrim
 import UniqFM
diff --git a/compiler/GHC/StgToCmm/Expr.hs b/compiler/GHC/StgToCmm/Expr.hs
index 38d35fc031..f39d02839c 100644
--- a/compiler/GHC/StgToCmm/Expr.hs
+++ b/compiler/GHC/StgToCmm/Expr.hs
@@ -28,7 +28,7 @@ import GHC.StgToCmm.Ticky
 import GHC.StgToCmm.Utils
 import GHC.StgToCmm.Closure
 
-import StgSyn
+import GHC.Stg.Syntax
 
 import MkGraph
 import BlockId
@@ -42,7 +42,7 @@ import Id
 import PrimOp
 import TyCon
 import Type             ( isUnliftedType )
-import RepType          ( isVoidTy, countConRepArgs )
+import GHC.Types.RepType          ( isVoidTy, countConRepArgs )
 import CostCentre       ( CostCentreStack, currentCCS )
 import Maybes
 import Util
@@ -585,7 +585,7 @@ isSimpleOp (StgPrimCallOp _) _                           = return False
 chooseReturnBndrs :: Id -> AltType -> [CgStgAlt] -> [NonVoid Id]
 -- These are the binders of a case that are assigned by the evaluation of the
 -- scrutinee.
--- They're non-void, see Note [Post-unarisation invariants] in UnariseStg.
+-- They're non-void, see Note [Post-unarisation invariants] in GHC.Stg.Unarise.
 chooseReturnBndrs bndr (PrimAlt _) _alts
   = assertNonVoidIds [bndr]
 
@@ -882,7 +882,7 @@ cgAltRhss gc_plan bndr alts = do
         maybeAltHeapCheck gc_plan $
         do { _ <- bindConArgs con base_reg (assertNonVoidIds bndrs)
                     -- alt binders are always non-void,
-                    -- see Note [Post-unarisation invariants] in UnariseStg
+                    -- see Note [Post-unarisation invariants] in GHC.Stg.Unarise
            ; _ <- cgExpr rhs
            ; return con }
   forkAlts (map cg_alt alts)
@@ -910,7 +910,7 @@ cgConApp con stg_args
     do  { (idinfo, fcode_init) <- buildDynCon (dataConWorkId con) False
                                      currentCCS con (assertNonVoidStgArgs stg_args)
                                      -- con args are always non-void,
-                                     -- see Note [Post-unarisation invariants] in UnariseStg
+                                     -- see Note [Post-unarisation invariants] in GHC.Stg.Unarise
                 -- The first "con" says that the name bound to this
                 -- closure is "con", which is a bit of a fudge, but
                 -- it only affects profiling (hence the False)
diff --git a/compiler/GHC/StgToCmm/Foreign.hs b/compiler/GHC/StgToCmm/Foreign.hs
index dacaff41ba..3ef0872c2e 100644
--- a/compiler/GHC/StgToCmm/Foreign.hs
+++ b/compiler/GHC/StgToCmm/Foreign.hs
@@ -20,7 +20,7 @@ module GHC.StgToCmm.Foreign (
 
 import GhcPrelude hiding( succ, (<*>) )
 
-import StgSyn
+import GHC.Stg.Syntax
 import GHC.StgToCmm.Prof (storeCurCCS, ccsType)
 import GHC.StgToCmm.Env
 import GHC.StgToCmm.Monad
@@ -33,7 +33,7 @@ import Cmm
 import CmmUtils
 import MkGraph
 import Type
-import RepType
+import GHC.Types.RepType
 import CLabel
 import SMRep
 import ForeignCall
diff --git a/compiler/GHC/StgToCmm/Heap.hs b/compiler/GHC/StgToCmm/Heap.hs
index a1f016c13c..d36cad5788 100644
--- a/compiler/GHC/StgToCmm/Heap.hs
+++ b/compiler/GHC/StgToCmm/Heap.hs
@@ -22,7 +22,7 @@ module GHC.StgToCmm.Heap (
 
 import GhcPrelude hiding ((<*>))
 
-import StgSyn
+import GHC.Stg.Syntax
 import CLabel
 import GHC.StgToCmm.Layout
 import GHC.StgToCmm.Utils
diff --git a/compiler/GHC/StgToCmm/Layout.hs b/compiler/GHC/StgToCmm/Layout.hs
index f4834376ed..6d7825eb93 100644
--- a/compiler/GHC/StgToCmm/Layout.hs
+++ b/compiler/GHC/StgToCmm/Layout.hs
@@ -48,7 +48,7 @@ import Cmm
 import CmmUtils
 import CmmInfo
 import CLabel
-import StgSyn
+import GHC.Stg.Syntax
 import Id
 import TyCon             ( PrimRep(..), primRepSizeB )
 import BasicTypes        ( RepArity )
diff --git a/compiler/GHC/StgToCmm/Prim.hs b/compiler/GHC/StgToCmm/Prim.hs
index 3728c0cac2..85924d984e 100644
--- a/compiler/GHC/StgToCmm/Prim.hs
+++ b/compiler/GHC/StgToCmm/Prim.hs
@@ -40,7 +40,7 @@ import GHC.Platform
 import BasicTypes
 import BlockId
 import MkGraph
-import StgSyn
+import GHC.Stg.Syntax
 import Cmm
 import Module   ( rtsUnitId )
 import Type     ( Type, tyConAppTyCon )
diff --git a/compiler/GHC/StgToCmm/Ticky.hs b/compiler/GHC/StgToCmm/Ticky.hs
index 7548f3de13..9eeb134cc9 100644
--- a/compiler/GHC/StgToCmm/Ticky.hs
+++ b/compiler/GHC/StgToCmm/Ticky.hs
@@ -111,7 +111,7 @@ import GHC.StgToCmm.Closure
 import GHC.StgToCmm.Utils
 import GHC.StgToCmm.Monad
 
-import StgSyn
+import GHC.Stg.Syntax
 import CmmExpr
 import MkGraph
 import CmmUtils
diff --git a/compiler/GHC/StgToCmm/Utils.hs b/compiler/GHC/StgToCmm/Utils.hs
index 0b3a8d8b08..34fb93468c 100644
--- a/compiler/GHC/StgToCmm/Utils.hs
+++ b/compiler/GHC/StgToCmm/Utils.hs
@@ -75,7 +75,7 @@ import UniqSupply (MonadUnique(..))
 import DynFlags
 import FastString
 import Outputable
-import RepType
+import GHC.Types.RepType
 
 import Data.ByteString (ByteString)
 import qualified Data.ByteString.Char8 as BS8
diff --git a/compiler/simplStg/RepType.hs b/compiler/GHC/Types/RepType.hs
index e6eb907f19..cdda659688 100644
--- a/compiler/simplStg/RepType.hs
+++ b/compiler/GHC/Types/RepType.hs
@@ -1,7 +1,7 @@
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE FlexibleContexts #-}
 
-module RepType
+module GHC.Types.RepType
   (
     -- * Code generator views onto Types
     UnaryType, NvUnaryType, isNvUnaryType,
@@ -133,7 +133,7 @@ isVoidTy = null . typePrimRep
 {- **********************************************************************
 *                                                                       *
                 Unboxed sums
- See Note [Translating unboxed sums to unboxed tuples] in UnariseStg.hs
+ See Note [Translating unboxed sums to unboxed tuples] in GHC.Stg.Unarise
 *                                                                       *
 ********************************************************************** -}
 
@@ -366,7 +366,7 @@ data RuntimeRep = VecRep VecCount VecElem   -- ^ a SIMD vector type
 It's all in 1-1 correspondence with PrimRep except for TupleRep and SumRep,
 which describe unboxed products and sums respectively. RuntimeRep is defined
 in the library ghc-prim:GHC.Types. It is also "wired-in" to GHC: see
-TysWiredIn.runtimeRepTyCon. The unarisation pass, in StgUnarise, transforms the
+TysWiredIn.runtimeRepTyCon. The unarisation pass, in GHC.Stg.Unarise, transforms the
 program, so that that every variable has a type that has a PrimRep. For
 example, unarisation transforms our utup function above, to take two Int
 arguments instead of one (# Int, Int #) argument.
diff --git a/compiler/basicTypes/Id.hs b/compiler/basicTypes/Id.hs
index c8872a30e7..d29a25cc02 100644
--- a/compiler/basicTypes/Id.hs
+++ b/compiler/basicTypes/Id.hs
@@ -133,7 +133,7 @@ import Var( Id, CoVar, JoinId,
 import qualified Var
 
 import Type
-import RepType
+import GHC.Types.RepType
 import TysPrim
 import DataCon
 import Demand
diff --git a/compiler/cmm/CmmUtils.hs b/compiler/cmm/CmmUtils.hs
index 1a28f94a0c..8920d2d6b9 100644
--- a/compiler/cmm/CmmUtils.hs
+++ b/compiler/cmm/CmmUtils.hs
@@ -71,7 +71,7 @@ module CmmUtils(
 import GhcPrelude
 
 import TyCon    ( PrimRep(..), PrimElemRep(..) )
-import RepType  ( UnaryType, SlotTy (..), typePrimRep1 )
+import GHC.Types.RepType  ( UnaryType, SlotTy (..), typePrimRep1 )
 
 import SMRep
 import Cmm
diff --git a/compiler/coreSyn/CoreLint.hs b/compiler/coreSyn/CoreLint.hs
index 6f551c009f..4aeb2cf698 100644
--- a/compiler/coreSyn/CoreLint.hs
+++ b/compiler/coreSyn/CoreLint.hs
@@ -47,7 +47,7 @@ import ErrUtils
 import Coercion
 import SrcLoc
 import Type
-import RepType
+import GHC.Types.RepType
 import TyCoRep       -- checks validity of types/coercions
 import TyCoSubst
 import TyCoFVs
diff --git a/compiler/deSugar/DsForeign.hs b/compiler/deSugar/DsForeign.hs
index 999fe02e12..0a3755e94b 100644
--- a/compiler/deSugar/DsForeign.hs
+++ b/compiler/deSugar/DsForeign.hs
@@ -31,7 +31,7 @@ import Literal
 import Module
 import Name
 import Type
-import RepType
+import GHC.Types.RepType
 import TyCon
 import Coercion
 import TcEnv
diff --git a/compiler/ghc.cabal.in b/compiler/ghc.cabal.in
index 2d3e3254ff..7fd83c9d8b 100644
--- a/compiler/ghc.cabal.in
+++ b/compiler/ghc.cabal.in
@@ -175,9 +175,7 @@ Library
         profiling
         rename
         simplCore
-        simplStg
         specialise
-        stgSyn
         stranal
         typecheck
         types
@@ -311,7 +309,6 @@ Library
         CoreArity
         CoreFVs
         CoreLint
-        CorePrep
         CoreSubst
         CoreOpt
         CoreSyn
@@ -454,23 +451,23 @@ Library
         SimplMonad
         SimplUtils
         Simplify
-        SimplStg
-        StgStats
-        StgCse
-        StgLiftLams
-        StgLiftLams.Analysis
-        StgLiftLams.LiftM
-        StgLiftLams.Transformation
-        StgSubst
-        UnariseStg
-        RepType
+        GHC.Stg.Pipeline
+        GHC.Stg.Stats
+        GHC.Stg.CSE
+        GHC.Stg.Lift
+        GHC.Stg.Lift.Analysis
+        GHC.Stg.Lift.Monad
+        GHC.Stg.Subst
+        GHC.Stg.Unarise
+        GHC.Stg.Lint
+        GHC.Stg.Syntax
+        GHC.Stg.FVs
+        GHC.CoreToStg
+        GHC.CoreToStg.Prep
+        GHC.Types.RepType
         Rules
         SpecConstr
         Specialise
-        CoreToStg
-        StgLint
-        StgSyn
-        StgFVs
         CallArity
         DmdAnal
         Exitify
diff --git a/compiler/ghci/ByteCodeGen.hs b/compiler/ghci/ByteCodeGen.hs
index 4a8e138daf..90931a4d74 100644
--- a/compiler/ghci/ByteCodeGen.hs
+++ b/compiler/ghci/ByteCodeGen.hs
@@ -37,7 +37,7 @@ import Literal
 import PrimOp
 import CoreFVs
 import Type
-import RepType
+import GHC.Types.RepType
 import DataCon
 import TyCon
 import Util
diff --git a/compiler/ghci/ByteCodeItbls.hs b/compiler/ghci/ByteCodeItbls.hs
index 11d90bf5ed..2138482051 100644
--- a/compiler/ghci/ByteCodeItbls.hs
+++ b/compiler/ghci/ByteCodeItbls.hs
@@ -19,7 +19,7 @@ import Name             ( Name, getName )
 import NameEnv
 import DataCon          ( DataCon, dataConRepArgTys, dataConIdentity )
 import TyCon            ( TyCon, tyConFamilySize, isDataTyCon, tyConDataCons )
-import RepType
+import GHC.Types.RepType
 import GHC.StgToCmm.Layout  ( mkVirtConstrSizes )
 import GHC.StgToCmm.Closure ( tagForCon, NonVoid (..) )
 import Util
diff --git a/compiler/ghci/RtClosureInspect.hs b/compiler/ghci/RtClosureInspect.hs
index 9fe18a57cf..da60eff5b6 100644
--- a/compiler/ghci/RtClosureInspect.hs
+++ b/compiler/ghci/RtClosureInspect.hs
@@ -33,7 +33,7 @@ import HscTypes
 
 import DataCon
 import Type
-import RepType
+import GHC.Types.RepType
 import qualified Unify as U
 import Var
 import TcRnMonad
diff --git a/compiler/main/HscMain.hs b/compiler/main/HscMain.hs
index 81f3caa033..016cad9303 100644
--- a/compiler/main/HscMain.hs
+++ b/compiler/main/HscMain.hs
@@ -123,16 +123,16 @@ import MkIface
 import Desugar
 import SimplCore
 import TidyPgm
-import CorePrep
-import CoreToStg        ( coreToStg )
+import GHC.CoreToStg.Prep
+import GHC.CoreToStg        ( coreToStg )
+import GHC.Stg.Syntax
+import GHC.Stg.FVs      ( annTopBindingsFreeVars )
+import GHC.Stg.Pipeline ( stg2stg )
 import qualified GHC.StgToCmm as StgToCmm ( codeGen )
-import StgSyn
-import StgFVs           ( annTopBindingsFreeVars )
 import CostCentre
 import ProfInit
 import TyCon
 import Name
-import SimplStg         ( stg2stg )
 import Cmm
 import CmmParse         ( parseCmmFile )
 import CmmBuildInfoTables
diff --git a/compiler/main/InteractiveEval.hs b/compiler/main/InteractiveEval.hs
index ac48c3f24f..eefa93ea02 100644
--- a/compiler/main/InteractiveEval.hs
+++ b/compiler/main/InteractiveEval.hs
@@ -61,7 +61,7 @@ import FamInstEnv ( FamInst )
 import CoreFVs    ( orphNamesOfFamInst )
 import TyCon
 import Type             hiding( typeKind )
-import RepType
+import GHC.Types.RepType
 import TcType
 import Constraint
 import TcOrigin
diff --git a/compiler/main/TidyPgm.hs b/compiler/main/TidyPgm.hs
index 47e89560b2..e94e0aaac0 100644
--- a/compiler/main/TidyPgm.hs
+++ b/compiler/main/TidyPgm.hs
@@ -21,7 +21,7 @@ import CoreUnfold
 import CoreFVs
 import CoreTidy
 import CoreMonad
-import CorePrep
+import GHC.CoreToStg.Prep
 import CoreUtils        (rhsIsStatic)
 import CoreStats        (coreBindsStats, CoreStats(..))
 import CoreSeq          (seqBinds)
diff --git a/compiler/prelude/PrimOp.hs b/compiler/prelude/PrimOp.hs
index f338a6094f..55a8bf339f 100644
--- a/compiler/prelude/PrimOp.hs
+++ b/compiler/prelude/PrimOp.hs
@@ -38,7 +38,7 @@ import Name
 import PrelNames        ( gHC_PRIMOPWRAPPERS )
 import TyCon            ( TyCon, isPrimTyCon, PrimRep(..) )
 import Type
-import RepType          ( typePrimRep1, tyConPrimRep1 )
+import GHC.Types.RepType          ( typePrimRep1, tyConPrimRep1 )
 import BasicTypes       ( Arity, Fixity(..), FixityDirection(..), Boxity(..),
                           SourceText(..) )
 import SrcLoc           ( wiredInSrcSpan )
diff --git a/compiler/prelude/TysWiredIn.hs b/compiler/prelude/TysWiredIn.hs
index ba427efee7..f4db7572c0 100644
--- a/compiler/prelude/TysWiredIn.hs
+++ b/compiler/prelude/TysWiredIn.hs
@@ -144,7 +144,7 @@ import Id
 import Constants        ( mAX_TUPLE_SIZE, mAX_CTUPLE_SIZE, mAX_SUM_SIZE )
 import Module           ( Module )
 import Type
-import RepType
+import GHC.Types.RepType
 import DataCon
 import {-# SOURCE #-} ConLike
 import TyCon
@@ -184,7 +184,7 @@ kept in sync with each other. The rule is this: use the order as declared
 in GHC.Types. All places where such lists exist should contain a reference
 to this Note, so a search for this Note's name should find all the lists.
 
-See also Note [Getting from RuntimeRep to PrimRep] in RepType.
+See also Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType.
 
 ************************************************************************
 *                                                                      *
@@ -1185,7 +1185,7 @@ vecRepDataCon = pcSpecialDataCon vecRepDataConName [ mkTyConTy vecCountTyCon
                                  runtimeRepTyCon
                                  (RuntimeRep prim_rep_fun)
   where
-    -- See Note [Getting from RuntimeRep to PrimRep] in RepType
+    -- See Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType
     prim_rep_fun [count, elem]
       | VecCount n <- tyConRuntimeRepInfo (tyConAppTyCon count)
       , VecElem  e <- tyConRuntimeRepInfo (tyConAppTyCon elem)
@@ -1200,7 +1200,7 @@ tupleRepDataCon :: DataCon
 tupleRepDataCon = pcSpecialDataCon tupleRepDataConName [ mkListTy runtimeRepTy ]
                                    runtimeRepTyCon (RuntimeRep prim_rep_fun)
   where
-    -- See Note [Getting from RuntimeRep to PrimRep] in RepType
+    -- See Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType
     prim_rep_fun [rr_ty_list]
       = concatMap (runtimeRepPrimRep doc) rr_tys
       where
@@ -1216,7 +1216,7 @@ sumRepDataCon :: DataCon
 sumRepDataCon = pcSpecialDataCon sumRepDataConName [ mkListTy runtimeRepTy ]
                                  runtimeRepTyCon (RuntimeRep prim_rep_fun)
   where
-    -- See Note [Getting from RuntimeRep to PrimRep] in RepType
+    -- See Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType
     prim_rep_fun [rr_ty_list]
       = map slotPrimRep (ubxSumRepType prim_repss)
       where
@@ -1230,7 +1230,7 @@ sumRepDataConTyCon :: TyCon
 sumRepDataConTyCon = promoteDataCon sumRepDataCon
 
 -- See Note [Wiring in RuntimeRep]
--- See Note [Getting from RuntimeRep to PrimRep] in RepType
+-- See Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType
 runtimeRepSimpleDataCons :: [DataCon]
 liftedRepDataCon :: DataCon
 runtimeRepSimpleDataCons@(liftedRepDataCon : _)
diff --git a/compiler/simplStg/StgLiftLams.hs b/compiler/simplStg/StgLiftLams.hs
deleted file mode 100644
index c3a9c8a478..0000000000
--- a/compiler/simplStg/StgLiftLams.hs
+++ /dev/null
@@ -1,102 +0,0 @@
--- | Implements a selective lambda lifter, running late in the optimisation
--- pipeline.
---
--- The transformation itself is implemented in "StgLiftLams.Transformation".
--- If you are interested in the cost model that is employed to decide whether
--- to lift a binding or not, look at "StgLiftLams.Analysis".
--- "StgLiftLams.LiftM" contains the transformation monad that hides away some
--- plumbing of the transformation.
-module StgLiftLams (
-    -- * Late lambda lifting in STG
-    -- $note
-    Transformation.stgLiftLams
-  ) where
-
-import qualified StgLiftLams.Transformation as Transformation
-
--- Note [Late lambda lifting in STG]
--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--- $note
--- See also the <https://gitlab.haskell.org/ghc/ghc/wikis/late-lam-lift wiki page>
--- and #9476.
---
--- The basic idea behind lambda lifting is to turn locally defined functions
--- into top-level functions. Free variables are then passed as additional
--- arguments at *call sites* instead of having a closure allocated for them at
--- *definition site*. Example:
---
--- @
---    let x = ...; y = ... in
---    let f = {x y} \a -> a + x + y in
---    let g = {f x} \b -> f b + x in
---    g 5
--- @
---
--- Lambda lifting @f@ would
---
---   1. Turn @f@'s free variables into formal parameters
---   2. Update @f@'s call site within @g@ to @f x y b@
---   3. Update @g@'s closure: Add @y@ as an additional free variable, while
---      removing @f@, because @f@ no longer allocates and can be floated to
---      top-level.
---   4. Actually float the binding of @f@ to top-level, eliminating the @let@
---      in the process.
---
--- This results in the following program (with free var annotations):
---
--- @
---    f x y a = a + x + y;
---    let x = ...; y = ... in
---    let g = {x y} \b -> f x y b + x in
---    g 5
--- @
---
--- This optimisation is all about lifting only when it is beneficial to do so.
--- The above seems like a worthwhile lift, judging from heap allocation:
--- We eliminate @f@'s closure, saving to allocate a closure with 2 words, while
--- not changing the size of @g@'s closure.
---
--- You can probably sense that there's some kind of cost model at play here.
--- And you are right! But we also employ a couple of other heuristics for the
--- lifting decision which are outlined in "StgLiftLams.Analysis#when".
---
--- The transformation is done in "StgLiftLams.Transformation", which calls out
--- to 'StgLiftLams.Analysis.goodToLift' for its lifting decision.
--- It relies on "StgLiftLams.LiftM", which abstracts some subtle STG invariants
--- into a monadic substrate.
---
--- Suffice to say: We trade heap allocation for stack allocation.
--- The additional arguments have to passed on the stack (or in registers,
--- depending on architecture) every time we call the function to save a single
--- heap allocation when entering the let binding. Nofib suggests a mean
--- improvement of about 1% for this pass, so it seems like a worthwhile thing to
--- do. Compile-times went up by 0.6%, so all in all a very modest change.
---
--- For a concrete example, look at @spectral/atom@. There's a call to 'zipWith'
--- that is ultimately compiled to something like this
--- (module desugaring/lowering to actual STG):
---
--- @
---    propagate dt = ...;
---    runExperiment ... =
---      let xs = ... in
---      let ys = ... in
---      let go = {dt go} \xs ys -> case (xs, ys) of
---            ([], []) -> []
---            (x:xs', y:ys') -> propagate dt x y : go xs' ys'
---      in go xs ys
--- @
---
--- This will lambda lift @go@ to top-level, speeding up the resulting program
--- by roughly one percent:
---
--- @
---    propagate dt = ...;
---    go dt xs ys = case (xs, ys) of
---      ([], []) -> []
---      (x:xs', y:ys') -> propagate dt x y : go dt xs' ys'
---    runExperiment ... =
---      let xs = ... in
---      let ys = ... in
---      in go dt xs ys
--- @
diff --git a/compiler/stranal/WwLib.hs b/compiler/stranal/WwLib.hs
index f8b398fbcd..6feb1ff065 100644
--- a/compiler/stranal/WwLib.hs
+++ b/compiler/stranal/WwLib.hs
@@ -31,7 +31,7 @@ import VarEnv           ( mkInScopeSet )
 import VarSet           ( VarSet )
 import Type
 import Predicate        ( isClassPred )
-import RepType          ( isVoidTy, typePrimRep )
+import GHC.Types.RepType          ( isVoidTy, typePrimRep )
 import Coercion
 import FamInstEnv
 import BasicTypes       ( Boxity(..) )
diff --git a/compiler/typecheck/TcType.hs b/compiler/typecheck/TcType.hs
index 90680f093f..cd2cb7c725 100644
--- a/compiler/typecheck/TcType.hs
+++ b/compiler/typecheck/TcType.hs
@@ -203,7 +203,7 @@ import VarSet
 import Coercion
 import Type
 import Predicate
-import RepType
+import GHC.Types.RepType
 import TyCon
 
 -- others:
diff --git a/compiler/types/TyCon.hs b/compiler/types/TyCon.hs
index 7166f85c02..9157c33c4e 100644
--- a/compiler/types/TyCon.hs
+++ b/compiler/types/TyCon.hs
@@ -1035,7 +1035,7 @@ mkDataTyConRhs cons
 -- constructor of 'PrimRep'. This data structure allows us to store this
 -- information right in the 'TyCon'. The other approach would be to look
 -- up things like @RuntimeRep@'s @PrimRep@ by known-key every time.
--- See also Note [Getting from RuntimeRep to PrimRep] in RepType
+-- See also Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType
 data RuntimeRepInfo
   = NoRRI       -- ^ an ordinary promoted data con
   | RuntimeRep ([Type] -> [PrimRep])
@@ -1411,14 +1411,14 @@ On the other hand, CmmType includes some "nonsense" values, such as
 CmmType GcPtrCat W32 on a 64-bit machine.
 
 The PrimRep type is closely related to the user-visible RuntimeRep type.
-See Note [RuntimeRep and PrimRep] in RepType.
+See Note [RuntimeRep and PrimRep] in GHC.Types.RepType.
 
 -}
 
 -- | A 'PrimRep' is an abstraction of a type.  It contains information that
 -- the code generator needs in order to pass arguments, return results,
--- and store values of this type. See also Note [RuntimeRep and PrimRep] in RepType
--- and Note [VoidRep] in RepType.
+-- and store values of this type. See also Note [RuntimeRep and PrimRep] in
+-- GHC.Types.RepType and Note [VoidRep] in GHC.Types.RepType.
 data PrimRep
   = VoidRep
   | LiftedRep