From 08f4b0b4a7a468409cb2c10ec7d6900e10572021 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliahub.com>
Date: Sat, 12 Oct 2024 05:37:55 +0000
Subject: [PATCH] Move Core.Compiler into Base

This is the first step in what I am hoping will eventually result in making
the compiler itself and upgradable stdlib. Over time, we've gained several
non-Base consumers of `Core.Compiler`, and we've reached a bit of a breaking
point where maintaining those downstream dependencies is getting more difficult
than the close coupling of Core.Compiler to the runtime is worth.

In this first step, I am moving Core.Compiler into Base, ending the duplication
of common data structure and generic functions between Core.Compiler and Base.
This split goes back quite far (although not all the way) to the early days of
Julia and predates the world-age mechanism.

The extant Base and Core.Compiler environments have some differences
(other than the duplication). I think the primary ones are (but I will add
more here if somebody points one out).

- `Core.Compiler` does not use `getproperty`
- `Core.Compiler` does not have extensible `==` equality

In this, I decided to retain the former by setting `getproperty = getfield`
for Core.Compiler itself (though of course not for the datatstructures shared
with Base). I don't think it's strictly necessary, but might as well.

For equality, I decided the easiest thing to do would be to try to merge
the equalities and see what happens. In general, Core.Compiler is relatively
restricted in the kinds of equality comparisons it can make, so I think it'll
work out fine, but we can revisit this.

This seems to be fully working and most of this is just moving code around.
I think most of that refactoring is independently useful, so I'll pull some
of it out into separate PRs to make this PR more manageable.
---
 base/Base.jl                                  | 267 +-----------------
 base/Base_compiler.jl                         | 261 +++++++++++++++++
 base/array.jl                                 |  29 +-
 base/bool.jl                                  |   2 +
 base/client.jl                                |   2 +-
 base/compiler/abstractinterpretation.jl       |   2 +-
 base/compiler/bootstrap.jl                    |   4 +-
 base/compiler/compiler.jl                     | 144 +++-------
 base/compiler/effects.jl                      |   8 +-
 .../ssair/EscapeAnalysis/EscapeAnalysis.jl    |  11 +-
 base/compiler/ssair/ir.jl                     |   1 +
 base/compiler/ssair/show.jl                   |  16 +-
 base/compiler/ssair/tarjan.jl                 |   2 +-
 base/compiler/typeinfer.jl                    |  24 +-
 base/compilerimg.jl                           |   4 +
 base/docs/Docs.jl                             |   7 +-
 base/docs/core.jl                             |  18 +-
 base/error.jl                                 |   1 +
 base/errorshow.jl                             |   2 +-
 base/essentials.jl                            |   6 +-
 base/float.jl                                 |   2 -
 base/iterators.jl                             |  16 +-
 base/meta.jl                                  |   2 +-
 base/opaque_closure.jl                        |   4 +-
 base/promotion.jl                             |  10 +-
 base/reduce.jl                                |   2 +
 base/reflection.jl                            |   4 +-
 base/show.jl                                  |  44 ++-
 base/stacktraces.jl                           |   4 +-
 base/sysimg.jl                                |   8 +-
 base/tuple.jl                                 |   3 +-
 src/jltypes.c                                 |  18 +-
 src/precompile_utils.c                        |  10 +-
 stdlib/InteractiveUtils/src/codeview.jl       |  18 +-
 stdlib/REPL/src/REPLCompletions.jl            |   2 +-
 sysimage.mk                                   |  10 +-
 test/ambiguous.jl                             |   7 +-
 test/backtrace.jl                             |   2 +-
 test/compiler/EscapeAnalysis/EAUtils.jl       |   4 -
 test/compiler/effects.jl                      |   2 +-
 test/docs.jl                                  |   2 +-
 test/misc.jl                                  |   2 +-
 42 files changed, 445 insertions(+), 542 deletions(-)
 create mode 100644 base/Base_compiler.jl
 create mode 100644 base/compilerimg.jl

diff --git a/base/Base.jl b/base/Base.jl
index 1e780bb15141a..eb8ae44fffc1e 100644
--- a/base/Base.jl
+++ b/base/Base.jl
@@ -1,223 +1,15 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-baremodule Base
-
-using Core.Intrinsics, Core.IR
-
-# to start, we're going to use a very simple definition of `include`
-# that doesn't require any function (except what we can get from the `Core` top-module)
-# start this big so that we don't have to resize before we have defined how to grow an array
-const _included_files = Array{Tuple{Module,String},1}(Core.undef, 400)
-setfield!(_included_files, :size, (1,))
-function include(mod::Module, path::String)
-    len = getfield(_included_files.size, 1)
-    memlen = _included_files.ref.mem.length
-    lenp1 = Core.add_int(len, 1)
-    if len === memlen # by the time this is true we hopefully will have defined _growend!
-        _growend!(_included_files, UInt(1))
-    else
-        setfield!(_included_files, :size, (lenp1,))
-    end
-    Core.memoryrefset!(Core.memoryref(_included_files.ref, lenp1), (mod, ccall(:jl_prepend_cwd, Any, (Any,), path)), :not_atomic, true)
-    Core.println(path)
-    ccall(:jl_uv_flush, Nothing, (Ptr{Nothing},), Core.io_pointer(Core.stdout))
-    Core.include(mod, path)
-end
-include(path::String) = include(Base, path)
-
-# from now on, this is now a top-module for resolving syntax
-const is_primary_base_module = ccall(:jl_module_parent, Ref{Module}, (Any,), Base) === Core.Main
-ccall(:jl_set_istopmod, Cvoid, (Any, Bool), Base, is_primary_base_module)
-
-# The @inline/@noinline macros that can be applied to a function declaration are not available
-# until after array.jl, and so we will mark them within a function body instead.
-macro inline()   Expr(:meta, :inline)   end
-macro noinline() Expr(:meta, :noinline) end
-
-macro _boundscheck() Expr(:boundscheck) end
-
-# Try to help prevent users from shooting them-selves in the foot
-# with ambiguities by defining a few common and critical operations
-# (and these don't need the extra convert code)
-getproperty(x::Module, f::Symbol) = (@inline; getglobal(x, f))
-getproperty(x::Type, f::Symbol) = (@inline; getfield(x, f))
-setproperty!(x::Type, f::Symbol, v) = error("setfield! fields of Types should not be changed")
-setproperty!(x::Array, f::Symbol, v) = error("setfield! fields of Array should not be changed")
-getproperty(x::Tuple, f::Int) = (@inline; getfield(x, f))
-setproperty!(x::Tuple, f::Int, v) = setfield!(x, f, v) # to get a decent error
-
-getproperty(x, f::Symbol) = (@inline; getfield(x, f))
-function setproperty!(x, f::Symbol, v)
-    ty = fieldtype(typeof(x), f)
-    val = v isa ty ? v : convert(ty, v)
-    return setfield!(x, f, val)
-end
-
-typeof(function getproperty end).name.constprop_heuristic = Core.FORCE_CONST_PROP
-typeof(function setproperty! end).name.constprop_heuristic = Core.FORCE_CONST_PROP
-
-dotgetproperty(x, f) = getproperty(x, f)
-
-getproperty(x::Module, f::Symbol, order::Symbol) = (@inline; getglobal(x, f, order))
-function setproperty!(x::Module, f::Symbol, v, order::Symbol=:monotonic)
-    @inline
-    ty = Core.get_binding_type(x, f)
-    val = v isa ty ? v : convert(ty, v)
-    return setglobal!(x, f, val, order)
+if isdefined(Base, :Compiler)
+ccall(:jl_init_restored_module, Cvoid, (Any,), Base)
+else
+include("Base_compiler.jl")
 end
-getproperty(x::Type, f::Symbol, order::Symbol) = (@inline; getfield(x, f, order))
-setproperty!(x::Type, f::Symbol, v, order::Symbol) = error("setfield! fields of Types should not be changed")
-getproperty(x::Tuple, f::Int, order::Symbol) = (@inline; getfield(x, f, order))
-setproperty!(x::Tuple, f::Int, v, order::Symbol) = setfield!(x, f, v, order) # to get a decent error
 
-getproperty(x, f::Symbol, order::Symbol) = (@inline; getfield(x, f, order))
-function setproperty!(x, f::Symbol, v, order::Symbol)
-    @inline
-    ty = fieldtype(typeof(x), f)
-    val = v isa ty ? v : convert(ty, v)
-    return setfield!(x, f, val, order)
-end
+const start_base_include = time_ns()
 
-function swapproperty!(x, f::Symbol, v, order::Symbol=:not_atomic)
-    @inline
-    ty = fieldtype(typeof(x), f)
-    val = v isa ty ? v : convert(ty, v)
-    return Core.swapfield!(x, f, val, order)
-end
-function modifyproperty!(x, f::Symbol, op, v, order::Symbol=:not_atomic)
-    @inline
-    return Core.modifyfield!(x, f, op, v, order)
-end
-function replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)
-    @inline
-    ty = fieldtype(typeof(x), f)
-    val = desired isa ty ? desired : convert(ty, desired)
-    return Core.replacefield!(x, f, expected, val, success_order, fail_order)
-end
-function setpropertyonce!(x, f::Symbol, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)
-    @inline
-    ty = fieldtype(typeof(x), f)
-    val = desired isa ty ? desired : convert(ty, desired)
-    return Core.setfieldonce!(x, f, val, success_order, fail_order)
-end
-
-function swapproperty!(x::Module, f::Symbol, v, order::Symbol=:not_atomic)
-    @inline
-    ty = Core.get_binding_type(x, f)
-    val = v isa ty ? v : convert(ty, v)
-    return Core.swapglobal!(x, f, val, order)
-end
-function modifyproperty!(x::Module, f::Symbol, op, v, order::Symbol=:not_atomic)
-    @inline
-    return Core.modifyglobal!(x, f, op, v, order)
-end
-function replaceproperty!(x::Module, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)
-    @inline
-    ty = Core.get_binding_type(x, f)
-    val = desired isa ty ? desired : convert(ty, desired)
-    return Core.replaceglobal!(x, f, expected, val, success_order, fail_order)
-end
-function setpropertyonce!(x::Module, f::Symbol, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)
-    @inline
-    ty = Core.get_binding_type(x, f)
-    val = desired isa ty ? desired : convert(ty, desired)
-    return Core.setglobalonce!(x, f, val, success_order, fail_order)
-end
-
-
-convert(::Type{Any}, Core.@nospecialize x) = x
-convert(::Type{T}, x::T) where {T} = x
-include("coreio.jl")
-
-eval(x) = Core.eval(Base, x)
-eval(m::Module, x) = Core.eval(m, x)
-
-# init core docsystem
-import Core: @doc, @__doc__, WrappedException, @int128_str, @uint128_str, @big_str, @cmd
-if isdefined(Core, :Compiler)
-    import Core.Compiler.CoreDocs
-    Core.atdoc!(CoreDocs.docm)
-end
-
-include("exports.jl")
-include("public.jl")
-
-if false
-    # simple print definitions for debugging. enable these if something
-    # goes wrong during bootstrap before printing code is available.
-    # otherwise, they just just eventually get (noisily) overwritten later
-    global show, print, println
-    show(io::IO, x) = Core.show(io, x)
-    print(io::IO, a...) = Core.print(io, a...)
-    println(io::IO, x...) = Core.println(io, x...)
-end
-
-"""
-    time_ns() -> UInt64
-
-Get the time in nanoseconds relative to some arbitrary time in the past. The primary use is for measuring the elapsed time
-between two moments in time.
-"""
-time_ns() = ccall(:jl_hrtime, UInt64, ())
-
-start_base_include = time_ns()
-
-# A warning to be interpolated in the docstring of every dangerous mutating function in Base, see PR #50824
-const _DOCS_ALIASING_WARNING = """
-!!! warning
-    Behavior can be unexpected when any mutated argument shares memory with any other argument.
-"""
-
-## Load essential files and libraries
-include("essentials.jl")
-include("ctypes.jl")
-include("gcutils.jl")
-include("generator.jl")
-include("runtime_internals.jl")
 include("reflection.jl")
-include("options.jl")
-
-# define invoke(f, T, args...; kwargs...), without kwargs wrapping
-# to forward to invoke
-function Core.kwcall(kwargs::NamedTuple, ::typeof(invoke), f, T, args...)
-    @inline
-    # prepend kwargs and f to the invoked from the user
-    T = rewrap_unionall(Tuple{Core.Typeof(kwargs), Core.Typeof(f), (unwrap_unionall(T)::DataType).parameters...}, T)
-    return invoke(Core.kwcall, T, kwargs, f, args...)
-end
-# invoke does not have its own call cache, but kwcall for invoke does
-setfield!(typeof(invoke).name.mt, :max_args, 3, :monotonic) # invoke, f, T, args...
-
-# define applicable(f, T, args...; kwargs...), without kwargs wrapping
-# to forward to applicable
-function Core.kwcall(kwargs::NamedTuple, ::typeof(applicable), @nospecialize(args...))
-    @inline
-    return applicable(Core.kwcall, kwargs, args...)
-end
-function Core._hasmethod(@nospecialize(f), @nospecialize(t)) # this function has a special tfunc (TODO: make this a Builtin instead like applicable)
-    tt = rewrap_unionall(Tuple{Core.Typeof(f), (unwrap_unionall(t)::DataType).parameters...}, t)
-    return Core._hasmethod(tt)
-end
-
 
-# core operations & types
-include("promotion.jl")
-include("tuple.jl")
-include("expr.jl")
-include("pair.jl")
-include("traits.jl")
-include("range.jl")
-include("error.jl")
-
-# core numeric operations & types
-==(x, y) = x === y
-include("bool.jl")
-include("number.jl")
-include("int.jl")
-include("operators.jl")
-include("pointer.jl")
-include("refvalue.jl")
-include("cmem.jl")
 include("refpointer.jl")
 
 # now replace the Pair constructor (relevant for NamedTuples) with one that calls our Base.convert
@@ -230,33 +22,6 @@ end
 # The REPL stdlib hooks into Base using this Ref
 const REPL_MODULE_REF = Ref{Module}(Base)
 
-include("checked.jl")
-using .Checked
-function cld end
-function fld end
-
-# Lazy strings
-include("strings/lazy.jl")
-
-# array structures
-include("indices.jl")
-include("genericmemory.jl")
-include("array.jl")
-include("abstractarray.jl")
-include("subarray.jl")
-include("views.jl")
-include("baseext.jl")
-
-include("c.jl")
-include("ntuple.jl")
-include("abstractdict.jl")
-include("iddict.jl")
-include("idset.jl")
-include("iterators.jl")
-using .Iterators: zip, enumerate, only
-using .Iterators: Flatten, Filter, product  # for generators
-using .Iterators: Stateful    # compat (was formerly used in reinterpretarray.jl)
-include("namedtuple.jl")
 
 # For OS specific stuff
 # We need to strcat things here, before strings are really defined
@@ -328,13 +93,6 @@ include("reduce.jl")
 ## core structures
 include("reshapedarray.jl")
 include("reinterpretarray.jl")
-include("bitarray.jl")
-include("bitset.jl")
-
-if !isdefined(Core, :Compiler)
-    include("docs/core.jl")
-    Core.atdoc!(CoreDocs.docm)
-end
 
 include("multimedia.jl")
 using .Multimedia
@@ -343,7 +101,6 @@ using .Multimedia
 include("some.jl")
 
 include("dict.jl")
-include("abstractset.jl")
 include("set.jl")
 
 # Strings
@@ -481,10 +238,6 @@ include("accumulate.jl")
 include("permuteddimsarray.jl")
 using .PermutedDimsArrays
 
-# basic data structures
-include("ordering.jl")
-using .Order
-
 # Combinatorics
 include("sort.jl")
 using .Sort
@@ -562,9 +315,8 @@ include("docs/basedocs.jl")
 # Documentation -- should always be included last in sysimg.
 include("docs/Docs.jl")
 using .Docs
-if isdefined(Core, :Compiler) && is_primary_base_module
-    Docs.loaddocs(Core.Compiler.CoreDocs.DOCS)
-end
+Docs.loaddocs(CoreDocs.DOCS)
+@eval CoreDocs DOCS = DocLinkedList()
 
 include("precompilation.jl")
 
@@ -582,6 +334,9 @@ a_method_to_overwrite_in_test() = inferencebarrier(1)
 include(mod::Module, _path::AbstractString) = _include(identity, mod, _path)
 include(mapexpr::Function, mod::Module, _path::AbstractString) = _include(mapexpr, mod, _path)
 
+# Compatibility with when Compiler was in Core
+@eval Core const Compiler = Main.Base.Compiler
+
 # External libraries vendored into Base
 Core.println("JuliaSyntax/src/JuliaSyntax.jl")
 include(@__MODULE__, string(BUILDROOT, "JuliaSyntax/src/JuliaSyntax.jl")) # include($BUILDROOT/base/JuliaSyntax/JuliaSyntax.jl)
@@ -678,5 +433,3 @@ end
 # Ensure this file is also tracked
 @assert !isassigned(_included_files, 1)
 _included_files[1] = (parentmodule(Base), abspath(@__FILE__))
-
-end # baremodule Base
diff --git a/base/Base_compiler.jl b/base/Base_compiler.jl
new file mode 100644
index 0000000000000..6908e69fb8782
--- /dev/null
+++ b/base/Base_compiler.jl
@@ -0,0 +1,261 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+using Core.Intrinsics, Core.IR
+
+# to start, we're going to use a very simple definition of `include`
+# that doesn't require any function (except what we can get from the `Core` top-module)
+# start this big so that we don't have to resize before we have defined how to grow an array
+const _included_files = Array{Tuple{Module,String},1}(Core.undef, 400)
+setfield!(_included_files, :size, (1,))
+function include(mod::Module, path::String)
+    len = getfield(_included_files.size, 1)
+    memlen = _included_files.ref.mem.length
+    lenp1 = Core.add_int(len, 1)
+    if len === memlen # by the time this is true we hopefully will have defined _growend!
+        _growend!(_included_files, UInt(1))
+    else
+        setfield!(_included_files, :size, (lenp1,))
+    end
+    Core.memoryrefset!(Core.memoryref(_included_files.ref, lenp1), (mod, ccall(:jl_prepend_cwd, Any, (Any,), path)), :not_atomic, true)
+    Core.println(path)
+    ccall(:jl_uv_flush, Nothing, (Ptr{Nothing},), Core.io_pointer(Core.stdout))
+    Core.include(mod, path)
+end
+include(path::String) = include(Base, path)
+
+# from now on, this is now a top-module for resolving syntax
+const is_primary_base_module = ccall(:jl_module_parent, Ref{Module}, (Any,), Base) === Core.Main
+ccall(:jl_set_istopmod, Cvoid, (Any, Bool), Base, is_primary_base_module)
+
+# The @inline/@noinline macros that can be applied to a function declaration are not available
+# until after array.jl, and so we will mark them within a function body instead.
+macro inline()   Expr(:meta, :inline)   end
+macro noinline() Expr(:meta, :noinline) end
+
+macro _boundscheck() Expr(:boundscheck) end
+
+# Try to help prevent users from shooting them-selves in the foot
+# with ambiguities by defining a few common and critical operations
+# (and these don't need the extra convert code)
+getproperty(x::Module, f::Symbol) = (@inline; getglobal(x, f))
+getproperty(x::Type, f::Symbol) = (@inline; getfield(x, f))
+setproperty!(x::Type, f::Symbol, v) = error("setfield! fields of Types should not be changed")
+setproperty!(x::Array, f::Symbol, v) = error("setfield! fields of Array should not be changed")
+getproperty(x::Tuple, f::Int) = (@inline; getfield(x, f))
+setproperty!(x::Tuple, f::Int, v) = setfield!(x, f, v) # to get a decent error
+
+getproperty(x, f::Symbol) = (@inline; getfield(x, f))
+function setproperty!(x, f::Symbol, v)
+    ty = fieldtype(typeof(x), f)
+    val = v isa ty ? v : convert(ty, v)
+    return setfield!(x, f, val)
+end
+
+typeof(function getproperty end).name.constprop_heuristic = Core.FORCE_CONST_PROP
+typeof(function setproperty! end).name.constprop_heuristic = Core.FORCE_CONST_PROP
+
+dotgetproperty(x, f) = getproperty(x, f)
+
+getproperty(x::Module, f::Symbol, order::Symbol) = (@inline; getglobal(x, f, order))
+function setproperty!(x::Module, f::Symbol, v, order::Symbol=:monotonic)
+    @inline
+    ty = Core.get_binding_type(x, f)
+    val = v isa ty ? v : convert(ty, v)
+    return setglobal!(x, f, val, order)
+end
+getproperty(x::Type, f::Symbol, order::Symbol) = (@inline; getfield(x, f, order))
+setproperty!(x::Type, f::Symbol, v, order::Symbol) = error("setfield! fields of Types should not be changed")
+getproperty(x::Tuple, f::Int, order::Symbol) = (@inline; getfield(x, f, order))
+setproperty!(x::Tuple, f::Int, v, order::Symbol) = setfield!(x, f, v, order) # to get a decent error
+
+getproperty(x, f::Symbol, order::Symbol) = (@inline; getfield(x, f, order))
+function setproperty!(x, f::Symbol, v, order::Symbol)
+    @inline
+    ty = fieldtype(typeof(x), f)
+    val = v isa ty ? v : convert(ty, v)
+    return setfield!(x, f, val, order)
+end
+
+function swapproperty!(x, f::Symbol, v, order::Symbol=:not_atomic)
+    @inline
+    ty = fieldtype(typeof(x), f)
+    val = v isa ty ? v : convert(ty, v)
+    return Core.swapfield!(x, f, val, order)
+end
+function modifyproperty!(x, f::Symbol, op, v, order::Symbol=:not_atomic)
+    @inline
+    return Core.modifyfield!(x, f, op, v, order)
+end
+function replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)
+    @inline
+    ty = fieldtype(typeof(x), f)
+    val = desired isa ty ? desired : convert(ty, desired)
+    return Core.replacefield!(x, f, expected, val, success_order, fail_order)
+end
+function setpropertyonce!(x, f::Symbol, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)
+    @inline
+    ty = fieldtype(typeof(x), f)
+    val = desired isa ty ? desired : convert(ty, desired)
+    return Core.setfieldonce!(x, f, val, success_order, fail_order)
+end
+
+function swapproperty!(x::Module, f::Symbol, v, order::Symbol=:not_atomic)
+    @inline
+    ty = Core.get_binding_type(x, f)
+    val = v isa ty ? v : convert(ty, v)
+    return Core.swapglobal!(x, f, val, order)
+end
+function modifyproperty!(x::Module, f::Symbol, op, v, order::Symbol=:not_atomic)
+    @inline
+    return Core.modifyglobal!(x, f, op, v, order)
+end
+function replaceproperty!(x::Module, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)
+    @inline
+    ty = Core.get_binding_type(x, f)
+    val = desired isa ty ? desired : convert(ty, desired)
+    return Core.replaceglobal!(x, f, expected, val, success_order, fail_order)
+end
+function setpropertyonce!(x::Module, f::Symbol, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)
+    @inline
+    ty = Core.get_binding_type(x, f)
+    val = desired isa ty ? desired : convert(ty, desired)
+    return Core.setglobalonce!(x, f, val, success_order, fail_order)
+end
+
+
+convert(::Type{Any}, Core.@nospecialize x) = x
+convert(::Type{T}, x::T) where {T} = x
+include("coreio.jl")
+
+import Core: @doc, @__doc__, WrappedException, @int128_str, @uint128_str, @big_str, @cmd
+
+# core docsystem
+include("docs/core.jl")
+Core.atdoc!(CoreDocs.docm)
+
+eval(x) = Core.eval(Base, x)
+eval(m::Module, x) = Core.eval(m, x)
+
+include("exports.jl")
+include("public.jl")
+
+if false
+    # simple print definitions for debugging. enable these if something
+    # goes wrong during bootstrap before printing code is available.
+    # otherwise, they just just eventually get (noisily) overwritten later
+    global show, print, println
+    show(io::IO, x) = Core.show(io, x)
+    print(io::IO, a...) = Core.print(io, a...)
+    println(io::IO, x...) = Core.println(io, x...)
+end
+
+"""
+    time_ns() -> UInt64
+
+Get the time in nanoseconds relative to some arbitrary time in the past. The primary use is for measuring the elapsed time
+between two moments in time.
+"""
+time_ns() = ccall(:jl_hrtime, UInt64, ())
+
+# A warning to be interpolated in the docstring of every dangerous mutating function in Base, see PR #50824
+const _DOCS_ALIASING_WARNING = """
+!!! warning
+    Behavior can be unexpected when any mutated argument shares memory with any other argument.
+"""
+
+## Load essential files and libraries
+include("essentials.jl")
+include("ctypes.jl")
+include("gcutils.jl")
+include("generator.jl")
+include("runtime_internals.jl")
+include("options.jl")
+
+# define invoke(f, T, args...; kwargs...), without kwargs wrapping
+# to forward to invoke
+function Core.kwcall(kwargs::NamedTuple, ::typeof(invoke), f, T, args...)
+    @inline
+    # prepend kwargs and f to the invoked from the user
+    T = rewrap_unionall(Tuple{Core.Typeof(kwargs), Core.Typeof(f), (unwrap_unionall(T)::DataType).parameters...}, T)
+    return invoke(Core.kwcall, T, kwargs, f, args...)
+end
+# invoke does not have its own call cache, but kwcall for invoke does
+setfield!(typeof(invoke).name.mt, :max_args, 3, :monotonic) # invoke, f, T, args...
+
+# define applicable(f, T, args...; kwargs...), without kwargs wrapping
+# to forward to applicable
+function Core.kwcall(kwargs::NamedTuple, ::typeof(applicable), @nospecialize(args...))
+    @inline
+    return applicable(Core.kwcall, kwargs, args...)
+end
+function Core._hasmethod(@nospecialize(f), @nospecialize(t)) # this function has a special tfunc (TODO: make this a Builtin instead like applicable)
+    tt = rewrap_unionall(Tuple{Core.Typeof(f), (unwrap_unionall(t)::DataType).parameters...}, t)
+    return Core._hasmethod(tt)
+end
+
+
+# core operations & types
+include("promotion.jl")
+include("tuple.jl")
+include("expr.jl")
+include("pair.jl")
+include("traits.jl")
+include("range.jl")
+include("error.jl")
+
+# core numeric operations & types
+==(x, y) = x === y
+include("bool.jl")
+include("number.jl")
+include("int.jl")
+include("operators.jl")
+include("pointer.jl")
+include("refvalue.jl")
+include("cmem.jl")
+
+include("checked.jl")
+using .Checked
+function cld end
+function fld end
+
+# Lazy strings
+include("strings/lazy.jl")
+
+# array structures
+include("indices.jl")
+include("genericmemory.jl")
+include("array.jl")
+include("abstractarray.jl")
+include("subarray.jl")
+include("views.jl")
+include("baseext.jl")
+
+include("c.jl")
+include("ntuple.jl")
+include("abstractset.jl")
+include("bitarray.jl")
+include("bitset.jl")
+include("abstractdict.jl")
+include("iddict.jl")
+include("idset.jl")
+include("iterators.jl")
+using .Iterators: zip, enumerate, only
+using .Iterators: Flatten, Filter, product  # for generators
+using .Iterators: Stateful    # compat (was formerly used in reinterpretarray.jl)
+include("namedtuple.jl")
+
+include("ordering.jl")
+using .Order
+
+include("compiler/compiler.jl")
+
+const _return_type = Compiler.return_type
+
+# Enable compiler
+Core.eval(Compiler, quote
+include("compiler/bootstrap.jl")
+ccall(:jl_set_typeinf_func, Cvoid, (Any,), typeinf_ext_toplevel)
+
+include("compiler/parsing.jl")
+Core._setparser!(fl_parse)
+end)
diff --git a/base/array.jl b/base/array.jl
index a628c1212659d..39476a5a5c281 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -758,28 +758,15 @@ end
 # gets inlined into the caller before recursion detection
 # gets a chance to see it, so that recursive calls to the caller
 # don't trigger the inference limiter
-if isdefined(Core, :Compiler)
-    macro default_eltype(itr)
-        I = esc(itr)
-        return quote
-            if $I isa Generator && ($I).f isa Type
-                T = ($I).f
-            else
-                T = Core.Compiler.return_type(_iterator_upper_bound, Tuple{typeof($I)})
-            end
-            promote_typejoin_union(T)
-        end
-    end
-else
-    macro default_eltype(itr)
-        I = esc(itr)
-        return quote
-            if $I isa Generator && ($I).f isa Type
-                promote_typejoin_union($I.f)
-            else
-                Any
-            end
+macro default_eltype(itr)
+    I = esc(itr)
+    return quote
+        if $I isa Generator && ($I).f isa Type
+            T = ($I).f
+        else
+            T = Base._return_type(_iterator_upper_bound, Tuple{typeof($I)})
         end
+        promote_typejoin_union(T)
     end
 end
 
diff --git a/base/bool.jl b/base/bool.jl
index d7dcf76caa91b..3a5c36b09ae2c 100644
--- a/base/bool.jl
+++ b/base/bool.jl
@@ -184,3 +184,5 @@ end
 div(x::Bool, y::Bool) = y ? x : throw(DivideError())
 rem(x::Bool, y::Bool) = y ? false : throw(DivideError())
 mod(x::Bool, y::Bool) = rem(x,y)
+
+Bool(x::Real) = x==0 ? false : x==1 ? true : throw(InexactError(:Bool, Bool, x))
diff --git a/base/client.jl b/base/client.jl
index a04556507d5dc..e95d518d3e501 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -557,7 +557,7 @@ function _start()
     try
         repl_was_requested = exec_options(JLOptions())
         if should_use_main_entrypoint() && !is_interactive
-            if Core.Compiler.generating_output()
+            if Base.generating_output()
                 precompile(Main.main, (typeof(ARGS),))
             else
                 ret = invokelatest(Main.main, ARGS)
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index dbe79e19bf9b4..6e63d0533017d 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2076,7 +2076,7 @@ function abstract_call_builtin(interp::AbstractInterpreter, f::Builtin, (; fargs
                 elsetype = rt === Const(true)  ? Bottom : widenslotwrapper(aty)
                 return Conditional(a, thentype, elsetype)
             end
-        elseif f === Core.Compiler.not_int
+        elseif f === Core.Intrinsics.not_int
             aty = argtypes[2]
             if isa(aty, Conditional)
                 thentype = rt === Const(false) ? Bottom : aty.elsetype
diff --git a/base/compiler/bootstrap.jl b/base/compiler/bootstrap.jl
index 12c83df74fe50..3162bccbdb4b9 100644
--- a/base/compiler/bootstrap.jl
+++ b/base/compiler/bootstrap.jl
@@ -6,7 +6,7 @@
 # since we won't be able to specialize & infer them at runtime
 
 let time() = ccall(:jl_clock_now, Float64, ())
-
+    println("Compiling the compiler. This may take several minutes ...")
     interp = NativeInterpreter()
 
     # analyze_escapes_tt = Tuple{typeof(analyze_escapes), IRCode, Int, TODO}
@@ -48,5 +48,5 @@ let time() = ccall(:jl_clock_now, Float64, ())
         end
     end
     endtime = time()
-    println("Core.Compiler ──── ", sub_float(endtime,starttime), " seconds")
+    println("Base.Compiler ──── ", sub_float(endtime,starttime), " seconds")
 end
diff --git a/base/compiler/compiler.jl b/base/compiler/compiler.jl
index 7d1dba88c9011..f4b7b73f1bf76 100644
--- a/base/compiler/compiler.jl
+++ b/base/compiler/compiler.jl
@@ -1,13 +1,38 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-getfield(Core, :eval)(Core, :(baremodule Compiler
+
+baremodule Compiler
 
 using Core.Intrinsics, Core.IR
 
-import Core: print, println, show, write, unsafe_write, stdout, stderr,
+import Core: print, println, show, write, unsafe_write,
              _apply_iterate, svec, apply_type, Builtin, IntrinsicFunction,
              MethodInstance, CodeInstance, MethodTable, MethodMatch, PartialOpaque,
-             TypeofVararg
+             TypeofVararg, Core, SimpleVector, donotdelete, compilerbarrier,
+             memoryref_isassigned, memoryrefnew, memoryrefoffset, memoryrefget,
+             memoryrefset!, typename
+
+using ..Base
+using ..Base: Ordering, vect, EffectsOverride, BitVector, @_gc_preserve_begin, @_gc_preserve_end, RefValue,
+    @nospecializeinfer, @_foldable_meta, fieldindex, is_function_def, indexed_iterate, isexpr, methods,
+    get_world_counter, JLOptions, _methods_by_ftype, unwrap_unionall, cconvert, unsafe_convert,
+    issingletontype, isType, rewrap_unionall, has_free_typevars, isvarargtype, hasgenerator,
+    IteratorSize, SizeUnknown, _array_for, Bottom, generating_output, diff_names,
+    ismutationfree, NUM_EFFECTS_OVERRIDES, _NAMEDTUPLE_NAME, datatype_fieldtypes,
+    argument_datatype, isfieldatomic, unwrapva, iskindtype, _bits_findnext, copy_exprargs,
+    Generator, Filter, ismutabletypename, isvatuple, datatype_fieldcount,
+    isconcretedispatch, isdispatchelem, min_world, max_world, datatype_layoutsize,
+    datatype_arrayelem, unionlen, isidentityfree, _uniontypes, uniontypes, OneTo, Callable,
+    DataTypeFieldDesc, datatype_nfields, datatype_pointerfree, midpoint, is_valid_intrinsic_elptr,
+    allocatedinline, isbitsunion, widen_diagonal, unconstrain_vararg_length,
+    rename_unionall, may_invoke_generator, is_meta_expr_head, is_meta_expr, quoted,
+    specialize_method, hasintersect, is_nospecializeinfer, is_nospecialized,
+    get_nospecializeinfer_sig, tls_world_age, uniontype_layout, kwerr,
+    moduleroot, is_file_tracked, decode_effects_override
+using ..Base.Order
+import ..Base: getindex, setindex!, length, iterate, push!, isempty, first, convert, ==,
+    copy, popfirst!, in, haskey, resize!, copy!, append!, last, get!, size,
+    get, iterate, findall
 
 const getproperty = Core.getfield
 const setproperty! = Core.setfield!
@@ -21,117 +46,19 @@ ccall(:jl_set_istopmod, Cvoid, (Any, Bool), Compiler, false)
 eval(x) = Core.eval(Compiler, x)
 eval(m, x) = Core.eval(m, x)
 
-include(x) = Core.include(Compiler, x)
-include(mod, x) = Core.include(mod, x)
-
-# The @inline/@noinline macros that can be applied to a function declaration are not available
-# until after array.jl, and so we will mark them within a function body instead.
-macro inline()   Expr(:meta, :inline)   end
-macro noinline() Expr(:meta, :noinline) end
+include(x) = Base.include(Compiler, x)
+include(mod, x) = Base.include(mod, x)
 
 macro _boundscheck() Expr(:boundscheck) end
 
-convert(::Type{Any}, Core.@nospecialize x) = x
-convert(::Type{T}, x::T) where {T} = x
-
 # These types are used by reflection.jl and expr.jl too, so declare them here.
 # Note that `@assume_effects` is available only after loading namedtuple.jl.
 abstract type MethodTableView end
 abstract type AbstractInterpreter end
 
-# essential files and libraries
-include("essentials.jl")
-include("ctypes.jl")
-include("generator.jl")
-include("runtime_internals.jl")
-include("options.jl")
-
-ntuple(f, ::Val{0}) = ()
-ntuple(f, ::Val{1}) = (@inline; (f(1),))
-ntuple(f, ::Val{2}) = (@inline; (f(1), f(2)))
-ntuple(f, ::Val{3}) = (@inline; (f(1), f(2), f(3)))
-ntuple(f, ::Val{n}) where {n} = ntuple(f, n::Int)
-ntuple(f, n) = (Any[f(i) for i = 1:n]...,)
-
-# core operations & types
 function return_type end # promotion.jl expects this to exist
 is_return_type(Core.@nospecialize(f)) = f === return_type
-include("promotion.jl")
-include("tuple.jl")
-include("pair.jl")
-include("traits.jl")
-include("range.jl")
-include("expr.jl")
-include("error.jl")
-
-# core numeric operations & types
-==(x::T, y::T) where {T} = x === y
-include("bool.jl")
-include("number.jl")
-include("int.jl")
-include("operators.jl")
-include("pointer.jl")
-include("refvalue.jl")
-
-# the same constructor as defined in float.jl, but with a different name to avoid redefinition
-_Bool(x::Real) = x==0 ? false : x==1 ? true : throw(InexactError(:Bool, Bool, x))
-# fld(x,y) == div(x,y) - ((x>=0) != (y>=0) && rem(x,y) != 0 ? 1 : 0)
-fld(x::T, y::T) where {T<:Unsigned} = div(x, y)
-function fld(x::T, y::T) where T<:Integer
-    d = div(x, y)
-    return d - (signbit(x ⊻ y) & (d * y != x))
-end
-# cld(x,y) = div(x,y) + ((x>0) == (y>0) && rem(x,y) != 0 ? 1 : 0)
-function cld(x::T, y::T) where T<:Unsigned
-    d = div(x, y)
-    return d + (d * y != x)
-end
-function cld(x::T, y::T) where T<:Integer
-    d = div(x, y)
-    return d + (((x > 0) == (y > 0)) & (d * y != x))
-end
 
-# checked arithmetic
-const checked_add = +
-const checked_sub = -
-const SignedInt = Union{Int8,Int16,Int32,Int64,Int128}
-const UnsignedInt = Union{UInt8,UInt16,UInt32,UInt64,UInt128}
-sub_with_overflow(x::T, y::T) where {T<:SignedInt}   = checked_ssub_int(x, y)
-sub_with_overflow(x::T, y::T) where {T<:UnsignedInt} = checked_usub_int(x, y)
-sub_with_overflow(x::Bool, y::Bool) = (x-y, false)
-add_with_overflow(x::T, y::T) where {T<:SignedInt}   = checked_sadd_int(x, y)
-add_with_overflow(x::T, y::T) where {T<:UnsignedInt} = checked_uadd_int(x, y)
-add_with_overflow(x::Bool, y::Bool) = (x+y, false)
-
-include("cmem.jl")
-include("strings/lazy.jl")
-
-# core array operations
-include("indices.jl")
-include("genericmemory.jl")
-include("array.jl")
-include("abstractarray.jl")
-
-# core structures
-include("bitarray.jl")
-include("bitset.jl")
-include("abstractdict.jl")
-include("iddict.jl")
-include("idset.jl")
-include("abstractset.jl")
-include("iterators.jl")
-using .Iterators: zip, enumerate
-using .Iterators: Flatten, Filter, product  # for generators
-include("namedtuple.jl")
-
-# core docsystem
-include("docs/core.jl")
-import Core.Compiler.CoreDocs
-Core.atdoc!(CoreDocs.docm)
-
-# sorting
-include("ordering.jl")
-using .Order
 include("compiler/sort.jl")
 
 # We don't include some.jl, but this definition is still useful.
@@ -144,7 +71,7 @@ something(x::Any, y...) = x
 
 baremodule BuildSettings
 using Core: ARGS, include
-using Core.Compiler: >, getindex, length
+using ..Compiler: >, getindex, length
 
 global MAX_METHODS::Int = 3
 
@@ -193,11 +120,4 @@ include("compiler/abstractinterpretation.jl")
 include("compiler/typeinfer.jl")
 include("compiler/optimize.jl")
 
-include("compiler/bootstrap.jl")
-ccall(:jl_set_typeinf_func, Cvoid, (Any,), typeinf_ext_toplevel)
-
-include("compiler/parsing.jl")
-Core._setparser!(fl_parse)
-
-end # baremodule Compiler
-))
+end
diff --git a/base/compiler/effects.jl b/base/compiler/effects.jl
index 3d9b69360b317..0a102ad7459dd 100644
--- a/base/compiler/effects.jl
+++ b/base/compiler/effects.jl
@@ -346,13 +346,13 @@ function decode_effects(e::UInt32)
     return Effects(
         UInt8((e >> 0) & 0x07),
         UInt8((e >> 3) & 0x03),
-        _Bool((e >> 5) & 0x01),
-        _Bool((e >> 6) & 0x01),
-        _Bool((e >> 7) & 0x01),
+        Bool((e >> 5) & 0x01),
+        Bool((e >> 6) & 0x01),
+        Bool((e >> 7) & 0x01),
         UInt8((e >> 8) & 0x03),
         UInt8((e >> 10) & 0x03),
         UInt8((e >> 12) & 0x03),
-        _Bool((e >> 14) & 0x01))
+        Bool((e >> 14) & 0x01))
 end
 
 decode_statement_effects_override(ssaflag::UInt32) =
diff --git a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
index 1f98758cd6055..370699f9f5735 100644
--- a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
+++ b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
@@ -22,15 +22,16 @@ using ._TOP_MOD:     # Base definitions
     @nospecialize, @specialize, BitSet, Callable, Csize_t, IdDict, IdSet, UnitRange, Vector,
     copy, delete!, empty!, enumerate, error, first, get, get!, haskey, in, isassigned,
     isempty, ismutabletype, keys, last, length, max, min, missing, pop!, push!, pushfirst!,
-    unwrap_unionall, !, !=, !==, &, *, +, -, :, <, <<, =>, >, |, ∈, ∉, ∩, ∪, ≠, ≤, ≥, ⊆
-using Core.Compiler: # Core.Compiler specific definitions
+    unwrap_unionall, !, !=, !==, &, *, +, -, :, <, <<, =>, >, |, ∈, ∉, ∩, ∪, ≠, ≤, ≥, ⊆,
+    hasintersect
+using ..Compiler: # Core.Compiler specific definitions
     AbstractLattice, Bottom, IRCode, IR_FLAG_NOTHROW, InferenceResult, SimpleInferenceLattice,
-    argextype, fieldcount_noerror, hasintersect, has_flag, intrinsic_nothrow,
+    argextype, fieldcount_noerror, has_flag, intrinsic_nothrow,
     is_meta_expr_head, is_mutation_free_argtype, isexpr, println, setfield!_nothrow,
-    singleton_type, try_compute_field, try_compute_fieldidx, widenconst, ⊑
+    singleton_type, try_compute_field, try_compute_fieldidx, widenconst, ⊑, Compiler
 
 include(x) = _TOP_MOD.include(@__MODULE__, x)
-if _TOP_MOD === Core.Compiler
+if _TOP_MOD === Compiler
     include("compiler/ssair/EscapeAnalysis/disjoint_set.jl")
 else
     include("disjoint_set.jl")
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 90eab43a3f25b..fb67d66100de4 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -272,6 +272,7 @@ function InstructionStream(len::Int)
 end
 InstructionStream() = InstructionStream(0)
 length(is::InstructionStream) = length(is.stmt)
+iterate(is::Compiler.InstructionStream, st::Int=1) = (st <= Compiler.length(is)) ? (is[st], st + 1) : nothing
 isempty(is::InstructionStream) = isempty(is.stmt)
 function add_new_idx!(is::InstructionStream)
     ninst = length(is) + 1
diff --git a/base/compiler/ssair/show.jl b/base/compiler/ssair/show.jl
index f3e11445d6c6c..2ad14c5c5b565 100644
--- a/base/compiler/ssair/show.jl
+++ b/base/compiler/ssair/show.jl
@@ -14,8 +14,6 @@ end
 
 import Base: show_unquoted
 using Base: printstyled, with_output_color, prec_decl, @invoke
-using Core.Compiler: VarState, InvalidIRError, argextype, widenconst, singleton_type,
-                     sptypes_from_meth_instance, EMPTY_SPTYPES
 
 function Base.show(io::IO, cfg::CFG)
     print(io, "CFG with $(length(cfg.blocks)) blocks:")
@@ -982,7 +980,7 @@ function show_ir(io::IO, ir::IRCode, config::IRShowConfig=default_config(ir);
                  pop_new_node! = new_nodes_iter(ir))
     used = stmts_used(io, ir)
     cfg = ir.cfg
-    maxssaid = length(ir.stmts) + Core.Compiler.length(ir.new_nodes)
+    maxssaid = length(ir.stmts) + Compiler.length(ir.new_nodes)
     let io = IOContext(io, :maxssaid=>maxssaid)
         show_ir_stmts(io, ir, 1:length(ir.stmts), config, ir.sptypes, used, cfg, 1; pop_new_node!)
     end
@@ -1039,13 +1037,13 @@ function show_ir(io::IO, compact::IncrementalCompact, config::IRShowConfig=defau
         still_to_be_inserted = (last(input_bb.stmts) - compact.idx) + count
 
         result_bb = result_bbs[compact.active_result_bb]
-        result_bbs[compact.active_result_bb] = Core.Compiler.BasicBlock(result_bb,
-            Core.Compiler.StmtRange(first(result_bb.stmts), compact.result_idx+still_to_be_inserted))
+        result_bbs[compact.active_result_bb] = Compiler.BasicBlock(result_bb,
+            Compiler.StmtRange(first(result_bb.stmts), compact.result_idx+still_to_be_inserted))
     end
     compact_cfg = CFG(result_bbs, Int[first(result_bbs[i].stmts) for i in 2:length(result_bbs)])
 
     pop_new_node! = new_nodes_iter(compact)
-    maxssaid = length(compact.result) + Core.Compiler.length(compact.new_new_nodes)
+    maxssaid = length(compact.result) + Compiler.length(compact.new_new_nodes)
     bb_idx = let io = IOContext(io, :maxssaid=>maxssaid)
         show_ir_stmts(io, compact, 1:compact.result_idx-1, config, compact.ir.sptypes,
                       used_compacted, compact_cfg, 1; pop_new_node!)
@@ -1066,8 +1064,8 @@ function show_ir(io::IO, compact::IncrementalCompact, config::IRShowConfig=defau
     inputs_bbs = copy(cfg.blocks)
     for (i, bb) in enumerate(inputs_bbs)
         if bb.stmts.stop < bb.stmts.start
-            inputs_bbs[i] = Core.Compiler.BasicBlock(bb,
-                Core.Compiler.StmtRange(last(bb.stmts), last(bb.stmts)))
+            inputs_bbs[i] = Compiler.BasicBlock(bb,
+                Compiler.StmtRange(last(bb.stmts), last(bb.stmts)))
             # this is not entirely correct, and will result in the bb starting again,
             # but is the best we can do without changing how `finish_current_bb!` works.
         end
@@ -1075,7 +1073,7 @@ function show_ir(io::IO, compact::IncrementalCompact, config::IRShowConfig=defau
     uncompacted_cfg = CFG(inputs_bbs, Int[first(inputs_bbs[i].stmts) for i in 2:length(inputs_bbs)])
 
     pop_new_node! = new_nodes_iter(compact.ir, compact.new_nodes_idx)
-    maxssaid = length(compact.ir.stmts) + Core.Compiler.length(compact.ir.new_nodes)
+    maxssaid = length(compact.ir.stmts) + Compiler.length(compact.ir.new_nodes)
     let io = IOContext(io, :maxssaid=>maxssaid)
         # first show any new nodes to be attached after the last compacted statement
         if compact.idx > 1
diff --git a/base/compiler/ssair/tarjan.jl b/base/compiler/ssair/tarjan.jl
index 3727fe218dc1d..e73039868c367 100644
--- a/base/compiler/ssair/tarjan.jl
+++ b/base/compiler/ssair/tarjan.jl
@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-using Core.Compiler: DomTree, CFG, BasicBlock, StmtRange, dominates
+using .Compiler: DomTree, CFG, BasicBlock, StmtRange, dominates
 
 struct SCCStackItem
     v::Int32
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 2a3bbf3854302..909ede2eda7a6 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -10,19 +10,19 @@ being used for this purpose alone.
 """
 module Timings
 
-using Core.Compiler: -, +, :, Vector, length, first, empty!, push!, pop!, @inline,
+using ..Compiler: -, +, :, Vector, length, first, empty!, push!, pop!, @inline,
     @inbounds, copy, backtrace
 
 # What we record for any given frame we infer during type inference.
 struct InferenceFrameInfo
     mi::Core.MethodInstance
     world::UInt64
-    sptypes::Vector{Core.Compiler.VarState}
+    sptypes::Vector{Compiler.VarState}
     slottypes::Vector{Any}
     nargs::Int
 end
 
-function _typeinf_identifier(frame::Core.Compiler.InferenceState)
+function _typeinf_identifier(frame::Compiler.InferenceState)
     mi_info = InferenceFrameInfo(
         frame.linfo,
         frame.world,
@@ -36,7 +36,7 @@ end
 _typeinf_identifier(frame::InferenceFrameInfo) = frame
 
 """
-    Core.Compiler.Timing(mi_info, start_time, ...)
+    Compiler.Timing(mi_info, start_time, ...)
 
 Internal type containing the timing result for running type inference on a single
 MethodInstance.
@@ -65,18 +65,18 @@ const _timings = Timing[]
 # ROOT() is an empty function used as the top-level Timing node to measure all time spent
 # *not* in type inference during a given recording trace. It is used as a "dummy" node.
 function ROOT() end
-const ROOTmi = Core.Compiler.specialize_method(
-    first(Core.Compiler.methods(ROOT)), Tuple{typeof(ROOT)}, Core.svec())
+const ROOTmi = Compiler.specialize_method(
+    first(Compiler.methods(ROOT)), Tuple{typeof(ROOT)}, Core.svec())
 """
-    Core.Compiler.reset_timings()
+    Compiler.reset_timings()
 
-Empty out the previously recorded type inference timings (`Core.Compiler._timings`), and
+Empty out the previously recorded type inference timings (`Compiler._timings`), and
 start the ROOT() timer again. `ROOT()` measures all time spent _outside_ inference.
 """
 function reset_timings() end
 push!(_timings, Timing(
     # The MethodInstance for ROOT(), and default empty values for other fields.
-    InferenceFrameInfo(ROOTmi, 0x0, Core.Compiler.VarState[], Any[Core.Const(ROOT)], 1),
+    InferenceFrameInfo(ROOTmi, 0x0, Compiler.VarState[], Any[Core.Const(ROOT)], 1),
     _time_ns()))
 function close_current_timer() end
 function enter_new_timer(frame) end
@@ -85,7 +85,7 @@ function exit_current_timer(_expected_frame_) end
 end  # module Timings
 
 """
-    Core.Compiler.__set_measure_typeinf(onoff::Bool)
+    Compiler.__set_measure_typeinf(onoff::Bool)
 
 If set to `true`, record per-method-instance timings within type inference in the Compiler.
 """
@@ -1155,7 +1155,7 @@ end
 function return_type(@nospecialize(f), t::DataType) # this method has a special tfunc
     world = tls_world_age()
     args = Any[_return_type, NativeInterpreter(world), Tuple{Core.Typeof(f), t.parameters...}]
-    return ccall(:jl_call_in_typeinf_world, Any, (Ptr{Ptr{Cvoid}}, Cint), args, length(args))
+    return ccall(:jl_call_in_typeinf_world, Any, (Ptr{Any}, Cint), args, length(args))
 end
 
 function return_type(@nospecialize(f), t::DataType, world::UInt)
@@ -1169,7 +1169,7 @@ end
 
 function return_type(t::DataType, world::UInt)
     args = Any[_return_type, NativeInterpreter(world), t]
-    return ccall(:jl_call_in_typeinf_world, Any, (Ptr{Ptr{Cvoid}}, Cint), args, length(args))
+    return ccall(:jl_call_in_typeinf_world, Any, (Ptr{Any}, Cint), args, length(args))
 end
 
 function _return_type(interp::AbstractInterpreter, t::DataType)
diff --git a/base/compilerimg.jl b/base/compilerimg.jl
new file mode 100644
index 0000000000000..c353ee614924b
--- /dev/null
+++ b/base/compilerimg.jl
@@ -0,0 +1,4 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+baremodule Base; end
+Core.include(Base, "Base_compiler.jl")
diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl
index 1a2403bbb8644..61c0cf71e70c2 100644
--- a/base/docs/Docs.jl
+++ b/base/docs/Docs.jl
@@ -750,15 +750,16 @@ include("utils.jl")
 # Swap out the bootstrap macro with the real one.
 Core.atdoc!(docm)
 
-function loaddocs(docs::Vector{Core.SimpleVector})
-    for (mod, ex, str, file, line) in docs
+function loaddocs(docs::Base.CoreDocs.DocLinkedList)
+    while isdefined(docs, :doc)
+        (mod, ex, str, file, line) = docs.doc
         data = Dict{Symbol,Any}(:path => string(file), :linenumber => line)
         doc = docstr(str, data)
         lno = LineNumberNode(line, file)
         docstring = docm(lno, mod, doc, ex, false) # expand the real @doc macro now
         Core.eval(mod, Expr(:var"hygienic-scope", docstring, Docs, lno))
+        docs = docs.next
     end
-    empty!(docs)
     nothing
 end
 
diff --git a/base/docs/core.jl b/base/docs/core.jl
index 718e49917632f..93265416099f9 100644
--- a/base/docs/core.jl
+++ b/base/docs/core.jl
@@ -2,15 +2,21 @@
 
 module CoreDocs
 
-import ..esc, ..push!, ..getindex, ..unsafe_load, ..Csize_t, ..@nospecialize
+import Core: @nospecialize, SimpleVector
 
-@nospecialize # don't specialize on any arguments of the methods declared herein
+struct DocLinkedList
+    doc::SimpleVector
+    next::DocLinkedList
+    DocLinkedList() = new()
+    DocLinkedList(doc::SimpleVector, next::DocLinkedList) = new(doc, next)
+end
 
+global DOCS = DocLinkedList()
 function doc!(source::LineNumberNode, mod::Module, str, ex)
-    push!(DOCS, Core.svec(mod, ex, str, source.file, source.line))
+    global DOCS
+    DOCS = DocLinkedList(Core.svec(mod, ex, str, source.file, source.line), DOCS)
     nothing
 end
-const DOCS = Array{Core.SimpleVector,1}()
 
 isexpr(x, h::Symbol) = isa(x, Expr) && x.head === h
 
@@ -25,9 +31,9 @@ function docm(source::LineNumberNode, mod::Module, str, x)
     else
         out = Expr(:block, x, out)
     end
-    return esc(out)
+    return Expr(:escape, out)
 end
 docm(source::LineNumberNode, mod::Module, x) =
-    isexpr(x, :->) ? docm(source, mod, x.args[1], x.args[2].args[2]) : error("invalid '@doc'.")
+    (isa(x, Expr) && x.head === :->) ? docm(source, mod, x.args[1], x.args[2].args[2]) : error("invalid '@doc'.")
 
 end
diff --git a/base/error.jl b/base/error.jl
index c49ede624607d..276555033443a 100644
--- a/base/error.jl
+++ b/base/error.jl
@@ -42,6 +42,7 @@ typeof(error).name.max_methods = UInt8(2)
 Raise an `ErrorException` with the given message.
 """
 error(s::AbstractString) = throw(ErrorException(s))
+error() = throw(ErrorException(""))
 
 """
     error(msg...)
diff --git a/base/errorshow.jl b/base/errorshow.jl
index 20bdee1de6ec0..111bf1e352a08 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -448,7 +448,7 @@ function show_method_candidates(io::IO, ex::MethodError, kwargs=[])
     # pool MethodErrors for these two functions.
     if f === convert && !isempty(arg_types_param)
         at1 = arg_types_param[1]
-        if isType(at1) && !Core.Compiler.has_free_typevars(at1)
+        if isType(at1) && !has_free_typevars(at1)
             push!(funcs, (at1.parameters[1], arg_types_param[2:end]))
         end
     end
diff --git a/base/essentials.jl b/base/essentials.jl
index 0e7be924c908c..6615efe6370c3 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -183,11 +183,7 @@ end
 _nameof(m::Module) = ccall(:jl_module_name, Ref{Symbol}, (Any,), m)
 
 function _is_internal(__module__)
-    if ccall(:jl_base_relative_to, Any, (Any,), __module__)::Module === Core.Compiler ||
-       _nameof(__module__) === :Base
-        return true
-    end
-    return false
+    return true
 end
 
 # can be used in place of `@assume_effects :total` (supposed to be used for bootstrapping)
diff --git a/base/float.jl b/base/float.jl
index ff628f0ac7126..90a5d8b1c66f4 100644
--- a/base/float.jl
+++ b/base/float.jl
@@ -248,8 +248,6 @@ for t1 in (Float16, Float32, Float64)
     end
 end
 
-Bool(x::Real) = x==0 ? false : x==1 ? true : throw(InexactError(:Bool, Bool, x))
-
 promote_rule(::Type{Float64}, ::Type{UInt128}) = Float64
 promote_rule(::Type{Float64}, ::Type{Int128}) = Float64
 promote_rule(::Type{Float32}, ::Type{UInt128}) = Float32
diff --git a/base/iterators.jl b/base/iterators.jl
index 8bd30991319b6..67e5f87ab9b65 100644
--- a/base/iterators.jl
+++ b/base/iterators.jl
@@ -18,14 +18,9 @@ using .Base:
     tail, fieldtypes, min, max, minimum, zero, oneunit, promote, promote_shape, LazyString
 using Core: @doc
 
-if Base !== Core.Compiler
 using .Base:
     cld, fld, SubArray, view, resize!, IndexCartesian
 using .Base.Checked: checked_mul
-else
-    # Checked.checked_mul is not available during bootstrapping:
-    const checked_mul = *
-end
 
 import .Base:
     first, last,
@@ -35,13 +30,9 @@ import .Base:
     getindex, setindex!, get, iterate,
     popfirst!, isdone, peek, intersect
 
-export enumerate, zip, rest, countfrom, take, drop, takewhile, dropwhile, cycle, repeated, product, flatten, flatmap
+export enumerate, zip, rest, countfrom, take, drop, takewhile, dropwhile, cycle, repeated, product, flatten, flatmap, partition
 public accumulate, filter, map, peel, reverse, Stateful
 
-if Base !== Core.Compiler
-export partition
-end
-
 """
     Iterators.map(f, iterators...)
 
@@ -279,10 +270,8 @@ pairs(v::Core.SimpleVector) = Pairs(v, LinearIndices(v))
 pairs(A::AbstractVector) = pairs(IndexLinear(), A)
 # pairs(v::Pairs) = v # listed for reference, but already defined from being an AbstractDict
 
-if Base !== Core.Compiler
 pairs(::IndexCartesian, A::AbstractArray) = Pairs(A, Base.CartesianIndices(axes(A)))
 pairs(A::AbstractArray)  = pairs(IndexCartesian(), A)
-end
 
 length(v::Pairs) = length(getfield(v, :itr))
 axes(v::Pairs) = axes(getfield(v, :itr))
@@ -1301,7 +1290,6 @@ true
 """
 flatmap(f, c...) = flatten(map(f, c...))
 
-if Base !== Core.Compiler # views are not defined
 @doc """
     partition(collection, n)
 
@@ -1508,8 +1496,6 @@ IteratorSize(::Type{<:Stateful{T}}) where {T} = IteratorSize(T) isa IsInfinite ?
 eltype(::Type{<:Stateful{T}}) where {T} = eltype(T)
 IteratorEltype(::Type{<:Stateful{T}}) where {T} = IteratorEltype(T)
 
-end # if statement several hundred lines above
-
 """
     only(x)
 
diff --git a/base/meta.jl b/base/meta.jl
index e648df29c12f9..bcf4fbf632ab2 100644
--- a/base/meta.jl
+++ b/base/meta.jl
@@ -449,7 +449,7 @@ function _partially_inline!(@nospecialize(x), slot_replacements::Vector{Any},
                 @assert isa(arg, Union{GlobalRef, Symbol})
                 return x
             end
-        elseif !Core.Compiler.is_meta_expr_head(head)
+        elseif !Base.is_meta_expr_head(head)
             partially_inline!(x.args, slot_replacements, type_signature, static_param_values,
                               slot_offset, statement_offset, boundscheck)
         end
diff --git a/base/opaque_closure.jl b/base/opaque_closure.jl
index 0f1fdf47afed8..26b39879ca852 100644
--- a/base/opaque_closure.jl
+++ b/base/opaque_closure.jl
@@ -38,8 +38,8 @@ macro opaque(ty, ex)
 end
 
 # OpaqueClosure construction from pre-inferred CodeInfo/IRCode
-using Core.Compiler: IRCode, SSAValue
-using Core: CodeInfo
+using Core: CodeInfo, SSAValue
+using Base.Compiler: IRCode
 
 function compute_ir_rettype(ir::IRCode)
     rt = Union{}
diff --git a/base/promotion.jl b/base/promotion.jl
index 689a4e4be8f39..6a2a9e84c33e1 100644
--- a/base/promotion.jl
+++ b/base/promotion.jl
@@ -208,7 +208,7 @@ function typejoin_union_tuple(T::DataType)
     c = Vector{Any}(undef, lr)
     for i = 1:lr
         pi = p[i]
-        U = Core.Compiler.unwrapva(pi)
+        U = unwrapva(pi)
         if U === Union{}
             ci = Union{}
         elseif U isa Union
@@ -218,7 +218,7 @@ function typejoin_union_tuple(T::DataType)
         else
             ci = promote_typejoin_union(U)
         end
-        if i == lr && Core.Compiler.isvarargtype(pi)
+        if i == lr && isvarargtype(pi)
             c[i] = isdefined(pi, :N) ? Vararg{ci, pi.N} : Vararg{ci}
         else
             c[i] = ci
@@ -494,12 +494,6 @@ max(x::Real, y::Real) = max(promote(x,y)...)
 min(x::Real, y::Real) = min(promote(x,y)...)
 minmax(x::Real, y::Real) = minmax(promote(x, y)...)
 
-if isdefined(Core, :Compiler)
-    const _return_type = Core.Compiler.return_type
-else
-    _return_type(@nospecialize(f), @nospecialize(t)) = Any
-end
-
 function TupleOrBottom(tt...)
     any(p -> p === Union{}, tt) && return Union{}
     return Tuple{tt...}
diff --git a/base/reduce.jl b/base/reduce.jl
index 0c37256b64fb5..952d71bb2a849 100644
--- a/base/reduce.jl
+++ b/base/reduce.jl
@@ -1333,6 +1333,8 @@ end
 end
 @inline _all_tuple(f, anymissing) = anymissing ? missing : true
 
+all(::Tuple{Missing}) = missing
+
 ## count
 
 _bool(f) = x->f(x)::Bool
diff --git a/base/reflection.jl b/base/reflection.jl
index 8fe8d324eb792..d915c0fb5aea2 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1,7 +1,5 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-const Compiler = Core.Compiler
-
 """
     code_lowered(f, types; generated=true, debuginfo=:default)
 
@@ -151,7 +149,7 @@ function method_instances(@nospecialize(f), @nospecialize(t), world::UInt)
     # this make a better error message than the typeassert that follows
     world == typemax(UInt) && error("code reflection cannot be used from generated functions")
     for match in _methods_by_ftype(tt, -1, world)::Vector
-        instance = Core.Compiler.specialize_method(match::Core.MethodMatch)
+        instance = specialize_method(match::Core.MethodMatch)
         push!(results, instance)
     end
     return results
diff --git a/base/show.jl b/base/show.jl
index a147c2037d70e..1944d3dd3a8b1 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-using Core.Compiler: has_typevar
+using .Compiler: has_typevar
 
 function show(io::IO, ::MIME"text/plain", u::UndefInitializer)
     show(io, u)
@@ -1356,10 +1356,7 @@ function show_mi(io::IO, mi::Core.MethodInstance, from_stackframe::Bool=false)
 end
 
 # These sometimes show up as Const-values in InferenceFrameInfo signatures
-show(io::IO, r::Core.Compiler.UnitRange) = show(io, r.start : r.stop)
-show(io::IO, mime::MIME{Symbol("text/plain")}, r::Core.Compiler.UnitRange) = show(io, mime, r.start : r.stop)
-
-function show(io::IO, mi_info::Core.Compiler.Timings.InferenceFrameInfo)
+function show(io::IO, mi_info::Compiler.Timings.InferenceFrameInfo)
     mi = mi_info.mi
     def = mi.def
     if isa(def, Method)
@@ -1380,8 +1377,8 @@ function show(io::IO, mi_info::Core.Compiler.Timings.InferenceFrameInfo)
     end
 end
 
-function show(io::IO, tinf::Core.Compiler.Timings.Timing)
-    print(io, "Core.Compiler.Timings.Timing(", tinf.mi_info, ") with ", length(tinf.children), " children")
+function show(io::IO, tinf::Compiler.Timings.Timing)
+    print(io, "Compiler.Timings.Timing(", tinf.mi_info, ") with ", length(tinf.children), " children")
 end
 
 function show_delim_array(io::IO, itr::Union{AbstractArray,SimpleVector}, op, delim, cl,
@@ -2821,21 +2818,14 @@ function show(io::IO, vm::Core.TypeofVararg)
 end
 
 module IRShow
-    const Compiler = Core.Compiler
+    import ..Compiler
     using Core.IR
     import ..Base
     import .Compiler: IRCode, CFG, scan_ssa_use!,
         isexpr, compute_basic_blocks, block_for_inst, IncrementalCompact,
-        Effects, ALWAYS_TRUE, ALWAYS_FALSE, DebugInfoStream, getdebugidx
-    Base.getindex(r::Compiler.StmtRange, ind::Integer) = Compiler.getindex(r, ind)
-    Base.size(r::Compiler.StmtRange) = Compiler.size(r)
-    Base.first(r::Compiler.StmtRange) = Compiler.first(r)
-    Base.last(r::Compiler.StmtRange) = Compiler.last(r)
-    Base.length(is::Compiler.InstructionStream) = Compiler.length(is)
-    Base.iterate(is::Compiler.InstructionStream, st::Int=1) = (st <= Compiler.length(is)) ? (is[st], st + 1) : nothing
-    Base.getindex(is::Compiler.InstructionStream, idx::Int) = Compiler.getindex(is, idx)
-    Base.getindex(node::Compiler.Instruction, fld::Symbol) = Compiler.getindex(node, fld)
-    Base.getindex(ir::IRCode, ssa::SSAValue) = Compiler.getindex(ir, ssa)
+        Effects, ALWAYS_TRUE, ALWAYS_FALSE, DebugInfoStream, getdebugidx,
+        VarState, InvalidIRError, argextype, widenconst, singleton_type,
+        sptypes_from_meth_instance, EMPTY_SPTYPES
     include("compiler/ssair/show.jl")
 
     const __debuginfo = Dict{Symbol, Any}(
@@ -2863,12 +2853,12 @@ function show(io::IO, src::CodeInfo; debuginfo::Symbol=:source)
     print(io, ")")
 end
 
-function show(io::IO, inferred::Core.Compiler.InferenceResult)
+function show(io::IO, inferred::Compiler.InferenceResult)
     mi = inferred.linfo
     tt = mi.specTypes.parameters[2:end]
     tts = join(["::$(t)" for t in tt], ", ")
     rettype = inferred.result
-    if isa(rettype, Core.Compiler.InferenceState)
+    if isa(rettype, Compiler.InferenceState)
         rettype = rettype.bestguess
     end
     if isa(mi.def, Method)
@@ -2878,19 +2868,19 @@ function show(io::IO, inferred::Core.Compiler.InferenceResult)
     end
 end
 
-show(io::IO, sv::Core.Compiler.InferenceState) =
+show(io::IO, sv::Compiler.InferenceState) =
     (print(io, "InferenceState for "); show(io, sv.linfo))
 
-show(io::IO, ::Core.Compiler.NativeInterpreter) =
+show(io::IO, ::Compiler.NativeInterpreter) =
     print(io, "Core.Compiler.NativeInterpreter(...)")
 
-show(io::IO, cache::Core.Compiler.CachedMethodTable) =
-    print(io, typeof(cache), "(", Core.Compiler.length(cache.cache), " entries)")
+show(io::IO, cache::Compiler.CachedMethodTable) =
+    print(io, typeof(cache), "(", Compiler.length(cache.cache), " entries)")
 
-function show(io::IO, limited::Core.Compiler.LimitedAccuracy)
-    print(io, "Core.Compiler.LimitedAccuracy(")
+function show(io::IO, limited::Compiler.LimitedAccuracy)
+    print(io, "Compiler.LimitedAccuracy(")
     show(io, limited.typ)
-    print(io, ", #= ", Core.Compiler.length(limited.causes), " cause(s) =#)")
+    print(io, ", #= ", Compiler.length(limited.causes), " cause(s) =#)")
 end
 
 function dump(io::IOContext, x::SimpleVector, n::Int, indent)
diff --git a/base/stacktraces.jl b/base/stacktraces.jl
index 102e415a22de2..c3d86fc8f5151 100644
--- a/base/stacktraces.jl
+++ b/base/stacktraces.jl
@@ -124,7 +124,7 @@ end
 
 const top_level_scope_sym = Symbol("top-level scope")
 
-function lookup(ip::Union{Base.InterpreterIP,Core.Compiler.InterpreterIP})
+function lookup(ip::Union{Base.InterpreterIP})
     code = ip.code
     if code === nothing
         # interpreted top-level expression with no CodeInfo
@@ -175,7 +175,7 @@ Return a stack trace in the form of a vector of `StackFrame`s. (By default stack
 doesn't return C functions, but this can be enabled.) When called without specifying a
 trace, `stacktrace` first calls `backtrace`.
 """
-Base.@constprop :none function stacktrace(trace::Vector{<:Union{Base.InterpreterIP,Core.Compiler.InterpreterIP,Ptr{Cvoid}}}, c_funcs::Bool=false)
+Base.@constprop :none function stacktrace(trace::Vector{<:Union{Base.InterpreterIP,Ptr{Cvoid}}}, c_funcs::Bool=false)
     stack = StackTrace()
     for ip in trace
         for frame in lookup(ip)
diff --git a/base/sysimg.jl b/base/sysimg.jl
index 966ed76751f28..d2e80243994fb 100644
--- a/base/sysimg.jl
+++ b/base/sysimg.jl
@@ -1,6 +1,12 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-Core.include(Main, "Base.jl")
+# Can be built either a monolith or with a minimal Base image that just has the
+# compiler.
+if isdefined(Main, :Base); else
+Core.eval(Main, :(baremodule Base; end))
+end
+
+Core.include(Base, "Base.jl")
 
 using .Base
 
diff --git a/base/tuple.jl b/base/tuple.jl
index fc213410cfd7c..15af44f2ff085 100644
--- a/base/tuple.jl
+++ b/base/tuple.jl
@@ -664,7 +664,8 @@ all(x::Tuple{}) = true
 all(x::Tuple{Bool}) = x[1]
 all(x::Tuple{Bool, Bool}) = x[1]&x[2]
 all(x::Tuple{Bool, Bool, Bool}) = x[1]&x[2]&x[3]
-# use generic reductions for the rest
+all(f, x::Tuple{}) = true
+all(f, x::Tuple{Any}) = all((f(x[1]),))
 
 any(x::Tuple{}) = false
 any(x::Tuple{Bool}) = x[1]
diff --git a/src/jltypes.c b/src/jltypes.c
index 11f1d11a14edc..1717b16d0e58d 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3954,14 +3954,16 @@ void post_image_load_hooks(void) {
     // Ensure that `Base` has been loaded.
     assert(jl_base_module != NULL);
 
-    jl_libdl_module = (jl_module_t *)jl_get_global(
-        ((jl_module_t *)jl_get_global(jl_base_module, jl_symbol("Libc"))),
-        jl_symbol("Libdl")
-    );
-    jl_libdl_dlopen_func = jl_get_global(
-        jl_libdl_module,
-        jl_symbol("dlopen")
-    );
+    jl_module_t *libc_module = (jl_module_t *)jl_get_global(jl_base_module, jl_symbol("Libc"));
+    if (libc_module) {
+        jl_libdl_module = (jl_module_t *)jl_get_global(libc_module, jl_symbol("Libdl"));
+    }
+    if (jl_libdl_module) {
+        jl_libdl_dlopen_func = jl_get_global(
+            jl_libdl_module,
+            jl_symbol("dlopen")
+        );
+    }
 }
 #undef XX
 
diff --git a/src/precompile_utils.c b/src/precompile_utils.c
index a78d1e66dbb51..fc361d8b88e6f 100644
--- a/src/precompile_utils.c
+++ b/src/precompile_utils.c
@@ -312,10 +312,12 @@ static void *jl_precompile_worklist(jl_array_t *worklist, jl_array_t *extext_met
             }
         }
     }
-    n = jl_array_nrows(new_ext_cis);
-    for (i = 0; i < n; i++) {
-        jl_code_instance_t *ci = (jl_code_instance_t*)jl_array_ptr_ref(new_ext_cis, i);
-        precompile_enq_specialization_(ci->def, m);
+    if (new_ext_cis) {
+        n = jl_array_nrows(new_ext_cis);
+        for (i = 0; i < n; i++) {
+            jl_code_instance_t *ci = (jl_code_instance_t*)jl_array_ptr_ref(new_ext_cis, i);
+            precompile_enq_specialization_(ci->def, m);
+        }
     }
     void *native_code = jl_precompile_(m, 1);
     JL_GC_POP();
diff --git a/stdlib/InteractiveUtils/src/codeview.jl b/stdlib/InteractiveUtils/src/codeview.jl
index e3ef0a14a6608..f7304919f8ea9 100644
--- a/stdlib/InteractiveUtils/src/codeview.jl
+++ b/stdlib/InteractiveUtils/src/codeview.jl
@@ -145,7 +145,7 @@ See also: [`@code_warntype`](@ref), [`code_typed`](@ref), [`code_lowered`](@ref)
 """
 function code_warntype(io::IO, @nospecialize(f), @nospecialize(tt=Base.default_tt(f));
                        world=Base.get_world_counter(),
-                       interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world),
+                       interp::Base.Compiler.AbstractInterpreter=Base.Compiler.NativeInterpreter(world),
                        debuginfo::Symbol=:default, optimize::Bool=false, kwargs...)
     (ccall(:jl_is_in_pure_context, Bool, ()) || world == typemax(UInt)) &&
         error("code reflection cannot be used from generated functions")
@@ -159,12 +159,12 @@ function code_warntype(io::IO, @nospecialize(f), @nospecialize(tt=Base.default_t
         return nothing
     end
     tt = Base.signature_type(f, tt)
-    matches = Core.Compiler.findall(tt, Core.Compiler.method_table(interp))
+    matches = findall(tt, Base.Compiler.method_table(interp))
     matches === nothing && Base.raise_match_failure(:code_warntype, tt)
     for match in matches.matches
         match = match::Core.MethodMatch
-        src = Core.Compiler.typeinf_code(interp, match, optimize)
-        mi = Core.Compiler.specialize_method(match)
+        src = Base.Compiler.typeinf_code(interp, match, optimize)
+        mi = Base.Compiler.specialize_method(match)
         mi.def isa Method && (nargs = (mi.def::Method).nargs)
         print_warntype_mi(io, mi)
         if src isa Core.CodeInfo
@@ -202,7 +202,7 @@ function _dump_function(@nospecialize(f), @nospecialize(t), native::Bool, wrappe
     if !isa(f, Core.OpaqueClosure)
         world = Base.get_world_counter()
         match = Base._which(signature_type(f, t); world)
-        mi = Core.Compiler.specialize_method(match)
+        mi = Base.specialize_method(match)
         # TODO: use jl_is_cacheable_sig instead of isdispatchtuple
         isdispatchtuple(mi.specTypes) || (warning = GENERIC_SIG_WARNING)
     else
@@ -213,9 +213,9 @@ function _dump_function(@nospecialize(f), @nospecialize(t), native::Bool, wrappe
             # specialization and we can't infer anything more precise either.
             world = f.source.primary_world
             mi = f.source.specializations::Core.MethodInstance
-            Core.Compiler.hasintersect(typeof(f).parameters[1], tt) || (warning = OC_MISMATCH_WARNING)
+            Base.hasintersect(typeof(f).parameters[1], tt) || (warning = OC_MISMATCH_WARNING)
         else
-            mi = Core.Compiler.specialize_method(f.source, Tuple{typeof(f.captures), tt.parameters...}, Core.svec())
+            mi = Base.specialize_method(f.source, Tuple{typeof(f.captures), tt.parameters...}, Core.svec())
             isdispatchtuple(mi.specTypes) || (warning = GENERIC_SIG_WARNING)
         end
     end
@@ -237,7 +237,7 @@ function _dump_function(@nospecialize(f), @nospecialize(t), native::Bool, wrappe
         if isempty(str)
             # if that failed (or we want metadata), use LLVM to generate more accurate assembly output
             if !isa(f, Core.OpaqueClosure)
-                src = Core.Compiler.typeinf_code(Core.Compiler.NativeInterpreter(world), mi, true)
+                src = Base.Compiler.typeinf_code(Base.Compiler.NativeInterpreter(world), mi, true)
             else
                 src, rt = Base.get_oc_code_rt(f, tt, true)
             end
@@ -246,7 +246,7 @@ function _dump_function(@nospecialize(f), @nospecialize(t), native::Bool, wrappe
         end
     else
         if !isa(f, Core.OpaqueClosure)
-            src = Core.Compiler.typeinf_code(Core.Compiler.NativeInterpreter(world), mi, true)
+            src = Base.Compiler.typeinf_code(Base.Compiler.NativeInterpreter(world), mi, true)
         else
             src, rt = Base.get_oc_code_rt(f, tt, true)
         end
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 77f7fdf15cc9c..7c0f9eee45c93 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -5,7 +5,7 @@ module REPLCompletions
 export completions, shell_completions, bslash_completions, completion_text
 
 using Core: Const
-const CC = Core.Compiler
+const CC = Base.Compiler
 using Base.Meta
 using Base: propertynames, something, IdSet
 using Base.Filesystem: _readdirx
diff --git a/sysimage.mk b/sysimage.mk
index d0e106d4ce3da..d3dee6906ccfa 100644
--- a/sysimage.mk
+++ b/sysimage.mk
@@ -22,6 +22,8 @@ $(build_private_libdir)/%.$(SHLIB_EXT): $(build_private_libdir)/%-o.a
 	@$(DSYMUTIL) $@
 
 COMPILER_SRCS := $(addprefix $(JULIAHOME)/, \
+		base/Base_compiler.jl \
+		base/compilerimg.jl \
 		base/boot.jl \
 		base/docs/core.jl \
 		base/abstractarray.jl \
@@ -49,7 +51,7 @@ COMPILER_SRCS := $(addprefix $(JULIAHOME)/, \
 		base/pointer.jl \
 		base/promotion.jl \
 		base/range.jl \
-		base/reflection.jl \
+		base/runtime_internals.jl \
 		base/traits.jl \
 		base/refvalue.jl \
 		base/tuple.jl)
@@ -60,13 +62,13 @@ BASE_SRCS := $(sort $(shell find $(JULIAHOME)/base -name \*.jl -and -not -name s
 STDLIB_SRCS := $(JULIAHOME)/base/sysimg.jl $(SYSIMG_STDLIBS_SRCS)
 RELBUILDROOT := $(call rel_path,$(JULIAHOME)/base,$(BUILDROOT)/base)/ # <-- make sure this always has a trailing slash
 
-$(build_private_libdir)/corecompiler.ji: $(COMPILER_SRCS)
+$(build_private_libdir)/basecompiler.ji: $(COMPILER_SRCS)
 	@$(call PRINT_JULIA, cd $(JULIAHOME)/base && \
 	$(call spawn,$(JULIA_EXECUTABLE)) -C "$(JULIA_CPU_TARGET)" $(HEAPLIM) --output-ji $(call cygpath_w,$@).tmp \
-		--startup-file=no --warn-overwrite=yes -g$(BOOTSTRAP_DEBUG_LEVEL) -O1 compiler/compiler.jl)
+		--startup-file=no --warn-overwrite=yes -g$(BOOTSTRAP_DEBUG_LEVEL) -O1 compilerimg.jl)
 	@mv $@.tmp $@
 
-$(build_private_libdir)/sys.ji: $(build_private_libdir)/corecompiler.ji $(JULIAHOME)/VERSION $(BASE_SRCS) $(STDLIB_SRCS)
+$(build_private_libdir)/sys.ji: $(build_private_libdir)/basecompiler.ji $(JULIAHOME)/VERSION $(BASE_SRCS) $(STDLIB_SRCS)
 	@$(call PRINT_JULIA, cd $(JULIAHOME)/base && \
 	if ! JULIA_BINDIR=$(call cygpath_w,$(build_bindir)) WINEPATH="$(call cygpath_w,$(build_bindir));$$WINEPATH" \
 			$(call spawn, $(JULIA_EXECUTABLE)) -g1 -O1 -C "$(JULIA_CPU_TARGET)" $(HEAPLIM) --output-ji $(call cygpath_w,$@).tmp $(JULIA_SYSIMG_BUILD_FLAGS) \
diff --git a/test/ambiguous.jl b/test/ambiguous.jl
index 2f8a4193cf592..43ec1aab0557d 100644
--- a/test/ambiguous.jl
+++ b/test/ambiguous.jl
@@ -192,8 +192,7 @@ end
 
     # some ambiguities involving Union{} type parameters may be expected, but not required
     let ambig = Set(detect_ambiguities(Core; recursive=true, ambiguous_bottom=true))
-        @test !isempty(ambig)
-        @test length(ambig) < 30
+        @test isempty(ambig)
     end
 
     STDLIB_DIR = Sys.STDLIB
@@ -349,10 +348,6 @@ end
     # TODO: review this list and remove everything between test_broken and test
     let need_to_handle_undef_sparam =
             Set{Method}(detect_unbound_args(Core; recursive=true))
-        pop!(need_to_handle_undef_sparam, which(Core.Compiler.eltype, Tuple{Type{Tuple{Any}}}))
-        @test_broken isempty(need_to_handle_undef_sparam)
-        pop!(need_to_handle_undef_sparam, which(Core.Compiler._cat, Tuple{Any, AbstractArray}))
-        pop!(need_to_handle_undef_sparam, first(methods(Core.Compiler.same_names)))
         @test isempty(need_to_handle_undef_sparam)
     end
     let need_to_handle_undef_sparam =
diff --git a/test/backtrace.jl b/test/backtrace.jl
index 68873678df57b..ee04a46b17304 100644
--- a/test/backtrace.jl
+++ b/test/backtrace.jl
@@ -237,7 +237,7 @@ let trace = try
     end
     @test trace[1].func === Symbol("top-level scope")
     @test trace[1].file === :a_filename
-    @test trace[1].line == 3
+    @test trace[1].line in (2, 3)
 end
 
 # issue #45171
diff --git a/test/compiler/EscapeAnalysis/EAUtils.jl b/test/compiler/EscapeAnalysis/EAUtils.jl
index 1f0a84f1a8365..179b4b4aeffc4 100644
--- a/test/compiler/EscapeAnalysis/EAUtils.jl
+++ b/test/compiler/EscapeAnalysis/EAUtils.jl
@@ -128,10 +128,6 @@ end
 using Core: Argument, SSAValue
 using .CC: widenconst, singleton_type
 
-if EA._TOP_MOD === CC
-    Base.getindex(estate::EscapeState, @nospecialize(x)) = CC.getindex(estate, x)
-end
-
 function get_name_color(x::EscapeInfo, symbol::Bool = false)
     getname(x) = string(nameof(x))
     if x === EA.⊥
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index cdc26cddc440d..3347901165e3e 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -924,7 +924,7 @@ unknown_sparam_nothrow2(x::Ref{Ref{T}}) where T = (T; nothing)
 # purely abstract recursion should not taint :terminates
 # https://github.com/JuliaLang/julia/issues/48983
 abstractly_recursive1() = abstractly_recursive2()
-abstractly_recursive2() = (Core.Compiler._return_type(abstractly_recursive1, Tuple{}); 1)
+abstractly_recursive2() = (Base._return_type(abstractly_recursive1, Tuple{}); 1)
 abstractly_recursive3() = abstractly_recursive2()
 @test_broken Core.Compiler.is_terminates(Base.infer_effects(abstractly_recursive3, ()))
 actually_recursive1(x) = actually_recursive2(x)
diff --git a/test/docs.jl b/test/docs.jl
index 92d45fe05e397..12ef9ed86eaee 100644
--- a/test/docs.jl
+++ b/test/docs.jl
@@ -1518,7 +1518,7 @@ struct B_20087 end
 # issue #27832
 
 _last_atdoc = Core.atdoc
-Core.atdoc!(Core.Compiler.CoreDocs.docm)  # test bootstrap doc system
+Core.atdoc!(Base.CoreDocs.docm)  # test bootstrap doc system
 
 """
 """
diff --git a/test/misc.jl b/test/misc.jl
index e089395ce4557..7f9992e22a3d7 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -560,7 +560,7 @@ struct ambigconvert; end # inject a problematic `convert` method to ensure it st
 Base.convert(::Any, v::ambigconvert) = v
 
 import Base.summarysize
-@test summarysize(Core) > (summarysize(Core.Compiler) + Base.summarysize(Core.Intrinsics)) > Core.sizeof(Core)
+@test summarysize(Core) > Base.summarysize(Core.Intrinsics) > Core.sizeof(Core)
 @test summarysize(Base) > 100_000 * sizeof(Ptr)
 
 let R = Ref{Any}(nothing), depth = 10^6